diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 0000000..13d14b2
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,225 @@
+# Gitlock Architecture
+
+## System Overview
+
+Gitlock is a repository intelligence platform that applies behavioral code analysis to help engineering teams understand their codebases through git history forensics. It's built as an Elixir umbrella application with four apps.
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                        gitlock (umbrella)                        │
+│                                                                  │
+│  ┌──────────────┐  ┌──────────────────┐                         │
+│  │ gitlock_cli   │  │  gitlock_phx     │                         │
+│  │ (CLI entry)   │  │  (Web + DB)      │                         │
+│  └──────┬───────┘  └────────┬─────────┘                         │
+│         │                   │                                    │
+│         │    ┌──────────────┴──────────────┐                     │
+│         │    │     gitlock_workflows       │                     │
+│         │    │  Pipeline model + Executor  │                     │
+│         │    └──────────────┬──────────────┘                     │
+│         │                   │                                    │
+│         └───────────┬───────┘                                    │
+│                     │                                            │
+│         ┌───────────┴───────────┐                                │
+│         │    gitlock_core       │                                │
+│         │  (analysis engine)    │                                │
+│         └───────────────────────┘                                │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+## Dependency Direction
+
+```
+gitlock_cli ──→ gitlock_core
+                     ↑
+gitlock_phx ──→ gitlock_workflows ──→ gitlock_core
+```
+
+- `gitlock_core` depends on nothing (pure analysis engine)
+- `gitlock_workflows` depends on `gitlock_core` (executor maps nodes to use cases)
+- `gitlock_phx` depends on `gitlock_workflows` (pipeline model + execution) and `gitlock_core` (direct analysis for landing page demo)
+- `gitlock_cli` depends on `gitlock_core` (direct use case invocation)
+
+---
+
+## App Responsibilities
+
+### gitlock_core — Analysis Engine
+
+Hexagonal architecture. Pure domain logic for behavioral code analysis.
+
+```
+gitlock_core/
+├── application/          # Use case orchestrators
+│   ├── use_case.ex       # Base behaviour + execute/2 macro
+│   ├── use_case_factory.ex
+│   └── use_cases/        # 7 analysis types
+│
+├── domain/
+│   ├── entities/         # Core domain objects (Commit, Author)
+│   ├── services/         # Pure analysis algorithms
+│   └── values/           # Value objects (Hotspot, FileHistory, etc.)
+│
+├── ports/                # Interface contracts (behaviours)
+├── adapters/             # Port implementations (git, reporters, complexity)
+└── infrastructure/       # Workspace management, adapter registry
+```
+
+**Public API:**
+
+```elixir
+GitlockCore.investigate(:hotspots, repo_path, options)
+# => {:ok, result} | {:error, reason}
+
+GitlockCore.available_investigations()
+# => [:hotspots, :couplings, :knowledge_silos, :code_age, :blast_radius, :coupled_hotspots, :summary]
+```
+
+Each use case follows: `resolve_dependencies → run_domain_logic → format_result`.
+
+#### Node Engine Runtime (feature/node-engine branch)
+
+A more sophisticated execution system exists on `feature/node-engine` inside `gitlock_core/runtime/`. This is a proper DAG execution engine with:
+
+```
+runtime/
+├── node.ex               # Behaviour: metadata/0, execute/3, validate_parameters/1
+├── engine.ex             # GenServer: execution lifecycle, async monitoring
+├── workflow.ex           # Workflow struct, Reactor compilation, n8n-compatible JSON
+├── context.ex            # Execution context: variables, logging, metrics, temp storage
+├── registry.ex           # GenServer: node discovery, registration, search
+├── validator.ex          # Structural validation, cycle detection, port compatibility
+├── nodes/
+│   ├── triggers/git_commits.ex    # Source: fetches commits via VCS adapter
+│   ├── analysis/hotspot.ex        # Wraps HotspotDetection domain service
+│   ├── analysis/complexity.ex     # Wraps DispatchAnalyzer
+│   ├── transform/extract_field.ex # Data reshaping between nodes
+│   └── output/csv_export.ex       # File output
+└── runtime_supervisor.ex          # Supervises Registry + Engine
+```
+
+**Key capabilities not in main:**
+- True DAG-based data flow (nodes pass data through ports)
+- Compiles workflows to Reactor instances for execution
+- Node behaviour allows extensible, pluggable analysis nodes
+- Execution context with variables, metrics, and logging
+- Comprehensive validation (cycle detection, port type checking, orphan detection)
+- 161 tests across all runtime modules
+
+**Status:** This has been moved to `gitlock_workflows/runtime/` and converged with the visual pipeline model. See PROGRESS.md for details.
+
+### gitlock_workflows — Pipeline Model + Execution
+
+Visual workflow system, DAG execution engine, and the bridge between them.
+
+```
+gitlock_workflows/
+├── pipeline.ex           # Visual DAG: nodes, edges, ports
+├── node.ex / edge.ex / port.ex  # Visual model structs
+├── node_catalog.ex       # Available node types + use_case_key
+├── compiler.ex           # Pipeline → Runtime.Workflow → Reactor
+├── executor.ex           # DAG executor: compile, topo-sort, execute with data flow
+├── serializer.ex         # Pipeline ↔ JSON for DB/UI
+├── templates.ex          # Pre-built pipeline configurations
+├── application.ex        # OTP app, starts RuntimeSupervisor
+├── runtime_supervisor.ex  # Supervises Registry + Engine
+└── runtime/
+    ├── node.ex           # Behaviour: metadata/execute/validate_parameters
+    ├── engine.ex         # GenServer: execution lifecycle, async monitoring
+    ├── workflow.ex       # Workflow struct, Reactor compilation
+    ├── context.ex        # Execution context (variables, logging, metrics)
+    ├── registry.ex       # GenServer: node discovery + registration
+    ├── validator.ex      # Cycle detection, port types, orphan detection
+    └── nodes/
+        ├── triggers/git_commits.ex
+        ├── analysis/{hotspot,coupling,knowledge_silo,code_age,
+        │                 coupled_hotspot,complexity,summary}.ex
+        ├── transform/extract_field.ex
+        └── output/csv_export.ex
+```
+
+**Execution path:**
+Pipeline → `Compiler.to_workflow/2` → Runtime.Workflow → topological sort → execute nodes in order
+
+The Executor compiles the visual Pipeline into a Runtime Workflow, sorts nodes topologically,
+then executes them in dependency order. Data flows through port connections — the git trigger
+fetches commits once and all downstream analyzers receive them through the DAG.
+
+### Converged Architecture
+
+The visual pipeline model and the runtime engine now live together in `gitlock_workflows`:
+
+| Layer | Purpose | Key modules |
+|-------|---------|-------------|
+| **Visual** | UI model, DB persistence | Pipeline, Node, Edge, Port, NodeCatalog, Serializer |
+| **Bridge** | Conversion between layers | Compiler (Pipeline → Workflow → Reactor) |
+| **Runtime** | DAG execution engine | Engine, Registry, Validator, Context, Workflow |
+| **Nodes** | Concrete analysis steps | 10 runtime nodes wrapping gitlock_core domain services |
+
+### gitlock_phx — Phoenix Web Application
+
+Web interface, persistence, and user management.
+
+```
+gitlock_phx/
+├── accounts/             # User auth (phx.gen.auth)
+├── pipelines/
+│   ├── saved_pipeline.ex # Ecto schema — pipeline config as JSONB
+│   └── pipeline_run.ex   # Ecto schema — execution history
+├── pipelines.ex          # Context — CRUD, hydration, template seeding
+│
+└── web/
+    ├── live/
+    │   ├── analyze_live.ex          # Single-URL analysis entry point
+    │   ├── workflow_live.ex         # Visual pipeline builder (SvelteFlow)
+    │   └── hotspots_preview_live.ex # Landing page demo
+    └── ...
+```
+
+**Database schema:**
+
+```
+pipelines
+├── id (bigint, PK)
+├── user_id (FK → users, nullable for templates)
+├── name (string)
+├── description (text)
+├── config (jsonb) ← serialized Pipeline struct
+├── is_template (boolean)
+└── timestamps
+
+pipeline_runs
+├── id (bigint, PK)
+├── pipeline_id (FK → pipelines)
+├── user_id (FK → users)
+├── repo_url (string)
+├── status (string: running | completed | failed)
+├── results (jsonb) ← node results keyed by node_id
+├── error (text)
+├── started_at / completed_at (utc_datetime)
+└── timestamps
+```
+
+### gitlock_cli — Command Line Interface
+
+Thin CLI entry point. Parses arguments, delegates to `gitlock_core` use cases directly.
+
+---
+
+## Key Design Decisions
+
+### Pipelines stored as JSONB blobs (not normalized)
+
+The entire pipeline graph is serialized into a single JSONB column. Pipeline structure changes frequently during editing and is always loaded/saved as a unit.
+
+### Hexagonal architecture in gitlock_core
+
+Ports define contracts, adapters implement them. Swapping git implementations, adding reporters, or mocking for tests doesn't touch domain logic.
+
+### Workflow execution via message passing
+
+The Executor sends `{:pipeline_progress, ...}` messages to a caller PID. This works naturally with LiveView's `handle_info`. For sync mode (CLI/tests), the caller is `nil` and notifications are no-ops.
+
+### Single source of truth for templates
+
+`GitlockWorkflows.Templates` defines all pipeline templates. `GitlockPhx.Pipelines.seed_templates!/0` delegates to it.
diff --git a/DESIGN.md b/DESIGN.md
new file mode 100644
index 0000000..72a0476
--- /dev/null
+++ b/DESIGN.md
@@ -0,0 +1,359 @@
+# Gitlock Design System
+
+> Style guide, component architecture, and frontend conventions for the Gitlock UI.
+
+## Stack
+
+| Layer         | Tool                        | Notes                                      |
+| ------------- | --------------------------- | ------------------------------------------ |
+| Styling       | Tailwind CSS v4             | Utility-first, `@plugin` syntax            |
+| Components    | daisyUI v5                  | Semantic class names on top of Tailwind     |
+| Interactivity | Svelte 5                    | Runes mode, compiled via esbuild-svelte    |
+| Flow Editor   | @xyflow/svelte              | Node-based workflow canvas                 |
+| Icons         | Heroicons (via Phoenix)     | `hero-*` classes in HEEx templates          |
+| Icons (JS)    | Lucide Svelte (planned)     | For Svelte components needing inline icons |
+| Bridge        | Phoenix LiveView Hooks      | `phx-hook` connects LiveView ↔ Svelte      |
+
+---
+
+## Color Palette
+
+We use daisyUI semantic color tokens so the entire UI respects light/dark theme switching automatically. **Never hardcode hex/oklch values in components.**
+
+### Semantic Tokens (use these)
+
+| Token               | Purpose                                  | Example class            |
+| -------------------- | ---------------------------------------- | ------------------------ |
+| `base-100/200/300`   | Page backgrounds, cards, surfaces        | `bg-base-200`            |
+| `base-content`       | Default text on base backgrounds         | `text-base-content`      |
+| `primary`            | CTAs, active states, key actions         | `btn-primary`            |
+| `secondary`          | Supporting actions, secondary nav        | `btn-secondary`          |
+| `accent`             | Highlights, badges, attention-grabbers   | `badge-accent`           |
+| `neutral`            | Borders, muted elements, dividers        | `border-neutral`         |
+| `info`               | Informational alerts, tooltips           | `alert-info`             |
+| `success`            | Completed runs, passing checks           | `badge-success`          |
+| `warning`            | Caution states, degraded metrics         | `alert-warning`          |
+| `error`              | Failed runs, validation errors           | `alert-error`            |
+
+### Analysis-Specific Colors
+
+For heatmaps, risk scores, and data visualization, define a consistent scale:
+
+| Risk Level | Tailwind Class    | Usage                         |
+| ---------- | ----------------- | ----------------------------- |
+| Critical   | `text-error`      | Hotspot score > 0.8           |
+| High       | `text-warning`    | Hotspot score 0.6–0.8         |
+| Medium     | `text-info`       | Hotspot score 0.3–0.6         |
+| Low        | `text-success`    | Hotspot score < 0.3           |
+| None       | `text-base-content/50` | No data / not analyzed   |
+
+---
+
+## Typography
+
+Use Tailwind's default font stack. No custom fonts unless we add them intentionally later.
+
+| Element        | Classes                                           |
+| -------------- | ------------------------------------------------- |
+| Page title     | `text-2xl font-bold`                              |
+| Section header | `text-lg font-semibold`                           |
+| Card title     | `text-base font-medium`                           |
+| Body text      | `text-sm` (default)                               |
+| Small/caption  | `text-xs text-base-content/60`                    |
+| Mono/code      | `font-mono text-sm`                               |
+| File paths     | `font-mono text-xs truncate`                      |
+
+---
+
+## Spacing & Layout
+
+### Page Shell
+
+```
+┌─────────────────────────────────────────────┐
+│  Navbar (fixed top, h-16)                   │
+├──────────┬──────────────────────────────────┤
+│ Sidebar  │  Main Content                    │
+│ (w-64)   │  (flex-1, p-6)                   │
+│          │                                  │
+│          │                                  │
+└──────────┴──────────────────────────────────┘
+```
+
+- **Navbar**: `navbar bg-base-100 border-b border-base-300 h-16`
+- **Sidebar**: `w-64 bg-base-200 border-r border-base-300 overflow-y-auto`
+- **Main content**: `flex-1 overflow-y-auto p-6`
+- **Full-bleed pages** (workflow canvas): skip padding, `h-[calc(100vh-4rem)]`
+
+### Spacing Scale
+
+Use Tailwind defaults. Prefer `gap-*` on flex/grid over margin:
+
+| Context           | Spacing  |
+| ----------------- | -------- |
+| Between sections  | `gap-8`  |
+| Between cards     | `gap-4`  |
+| Inside cards      | `p-4`    |
+| Between form rows | `gap-3`  |
+| Inline elements   | `gap-2`  |
+| Icon + text       | `gap-1.5`|
+
+---
+
+## Component Patterns
+
+### daisyUI Components (use in HEEx & Svelte)
+
+Prefer daisyUI class-based components over building from scratch:
+
+| Need                | daisyUI Component          | Class Example                    |
+| ------------------- | -------------------------- | -------------------------------- |
+| Buttons             | `btn`                      | `btn btn-primary btn-sm`         |
+| Cards               | `card`                     | `card bg-base-200 shadow-sm`     |
+| Forms               | `input`, `select`, `label` | `input input-bordered input-sm`  |
+| Navigation          | `menu`, `navbar`           | `menu menu-sm`                   |
+| Feedback            | `alert`, `toast`           | `alert alert-info`               |
+| Data display         | `badge`, `table`           | `badge badge-success badge-sm`   |
+| Loading             | `loading`                  | `loading loading-spinner`        |
+| Modals              | `modal`                    | `modal` + `dialog` element       |
+| Tabs                | `tabs`                     | `tabs tabs-bordered`             |
+| Dropdown            | `dropdown`                 | `dropdown dropdown-end`          |
+| Tooltip             | `tooltip`                  | `tooltip` + `data-tip`           |
+| Progress            | `progress`, `radial-progress` | `progress progress-primary`  |
+| Toggle/checkbox     | `toggle`, `checkbox`       | `toggle toggle-primary toggle-sm`|
+| Collapse/accordion  | `collapse`                 | `collapse collapse-arrow`        |
+
+### Button Hierarchy
+
+| Level     | Classes                          | When                               |
+| --------- | -------------------------------- | ---------------------------------- |
+| Primary   | `btn btn-primary`                | One per page/section, main CTA     |
+| Secondary | `btn btn-secondary btn-outline`  | Supporting actions                 |
+| Ghost     | `btn btn-ghost`                  | Navigation, toolbar, low emphasis  |
+| Danger    | `btn btn-error btn-outline`      | Destructive actions                |
+| Sizes     | `btn-xs`, `btn-sm`, `btn-md`     | `btn-sm` is default in app chrome  |
+
+---
+
+## Svelte Component Architecture
+
+### Directory Structure
+
+```
+assets/svelte/
+├── components/           # Reusable UI primitives
+│   ├── Badge.svelte
+│   ├── EmptyState.svelte
+│   ├── MetricCard.svelte
+│   ├── RiskBadge.svelte
+│   └── FilePathDisplay.svelte
+├── workflow/             # Workflow canvas & nodes
+│   ├── WorkflowCanvas.svelte
+│   ├── nodes/
+│   │   ├── AnalysisNode.svelte
+│   │   ├── SourceNode.svelte
+│   │   ├── TransformNode.svelte
+│   │   └── OutputNode.svelte
+│   ├── panels/
+│   │   ├── NodeConfigPanel.svelte
+│   │   └── WorkflowToolbar.svelte
+│   └── stores.js
+├── analysis/             # Analysis result displays
+│   ├── HotspotTable.svelte
+│   ├── CouplingMatrix.svelte
+│   ├── KnowledgeMap.svelte
+│   └── ComplexityChart.svelte
+├── dashboard/            # Dashboard widgets
+│   ├── RepoHealthCard.svelte
+│   ├── RecentRunsList.svelte
+│   └── RiskOverview.svelte
+└── shared/               # Cross-cutting utilities
+    ├── stores.js         # Global Svelte stores
+    └── utils.js          # Formatting, helpers
+```
+
+### Svelte ↔ LiveView Bridge Pattern
+
+Every Svelte component that mounts from LiveView follows this pattern:
+
+```javascript
+// In assets/js/hooks/my_hook.js
+import MyComponent from "../svelte/path/MyComponent.svelte";
+
+export const MyHook = {
+  mounted() {
+    const props = JSON.parse(this.el.dataset.props || "{}");
+
+    this.component = new MyComponent({
+      target: this.el,
+      props: {
+        ...props,
+        pushEvent: (event, payload) => this.pushEvent(event, payload),
+      },
+    });
+  },
+
+  updated() {
+    const props = JSON.parse(this.el.dataset.props || "{}");
+    // Update reactive props via Svelte 5 $set or re-mount
+  },
+
+  destroyed() {
+    this.component?.$destroy();
+  },
+};
+```
+
+```elixir
+# In LiveView template
+<div id="my-component"
+     phx-hook="MyHook"
+     data-props={Jason.encode!(@component_data)}>
+</div>
+```
+
+### Svelte Component Conventions
+
+1. **Props interface**: Always define with `let { prop1, prop2 } = $props()` (Svelte 5 runes)
+2. **Events to LiveView**: Use `pushEvent` prop, never direct WebSocket access
+3. **Styling**: Use Tailwind/daisyUI classes. Scoped `<style>` only for complex animations or @xyflow overrides
+4. **Size**: Keep components < 150 lines. Extract sub-components when exceeding
+5. **State**: Local state with `$state()`. Shared state via stores in the same feature directory
+
+---
+
+## Page-Specific Patterns
+
+### Dashboard
+
+- Grid layout: `grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-4`
+- Each widget is a `card bg-base-200 shadow-sm`
+- Empty states use `EmptyState.svelte` with icon + description + action
+
+### Workflow Editor
+
+- Full viewport height: `h-[calc(100vh-4rem)]`
+- Canvas background: daisyUI `base-300`
+- Node styling: `card bg-base-100 shadow-md border border-base-300`
+- Selected node: `ring-2 ring-primary`
+- Node header colors by type:
+  - Source: `bg-info/10 text-info`
+  - Analysis: `bg-primary/10 text-primary`
+  - Transform: `bg-warning/10 text-warning`
+  - Output: `bg-success/10 text-success`
+
+### Analysis Results
+
+- Tables: `table table-sm table-zebra`
+- Sort indicators: `hero-chevron-up` / `hero-chevron-down`
+- File paths: `font-mono text-xs` with truncation + tooltip on hover
+- Metrics: Use `MetricCard` with label, value, trend indicator
+
+### Pipeline Runs
+
+- Status badges:
+  - Running: `badge badge-info` + `loading loading-spinner loading-xs`
+  - Success: `badge badge-success`
+  - Failed: `badge badge-error`
+  - Pending: `badge badge-ghost`
+- Timeline: vertical `steps steps-vertical` from daisyUI
+
+---
+
+## Interaction Patterns
+
+### Loading States
+
+| Context           | Pattern                                           |
+| ----------------- | ------------------------------------------------- |
+| Page load         | Skeleton loader (daisyUI `skeleton` class)        |
+| Button action     | `btn` with `loading loading-spinner loading-sm`   |
+| Table refresh     | Subtle opacity: `opacity-60 pointer-events-none`  |
+| Long operation    | `progress` bar + status text                      |
+
+### Empty States
+
+Always provide:
+1. An icon (hero-* or inline SVG)
+2. A clear message
+3. An action to resolve (button or link)
+
+```html
+<div class="flex flex-col items-center justify-center gap-4 py-16 text-base-content/50">
+  <span class="hero-folder-open h-12 w-12" />
+  <p class="text-sm">No pipelines yet</p>
+  <button class="btn btn-primary btn-sm">Create your first pipeline</button>
+</div>
+```
+
+### Toasts & Notifications
+
+Use Phoenix flash messages styled with daisyUI `alert`:
+
+```html
+<div class="toast toast-end">
+  <div class="alert alert-success">
+    <span>Pipeline saved successfully</span>
+  </div>
+</div>
+```
+
+---
+
+## Dark Mode
+
+Handled automatically by daisyUI theme switching. Rules:
+
+1. **Never use `bg-white`, `bg-black`, `text-gray-*`** — always semantic tokens
+2. **Borders**: `border-base-300` (not `border-gray-200`)
+3. **Shadows**: `shadow-sm` or `shadow-md` (Tailwind adapts)
+4. **Hover states**: Use `/10` or `/20` opacity variants: `hover:bg-primary/10`
+5. **Theme toggle**: In navbar, use daisyUI `swap` or `toggle` with JS to flip `data-theme`
+
+---
+
+## Responsive Breakpoints
+
+| Breakpoint | Usage                            |
+| ---------- | -------------------------------- |
+| `sm`       | Stack sidebar below content      |
+| `md`       | 2-column grid for dashboard      |
+| `lg`       | Sidebar visible by default       |
+| `xl`       | 3-column dashboard, wider panels |
+
+The workflow editor is **desktop-only** — show a message on mobile suggesting desktop use.
+
+---
+
+## Naming Conventions
+
+| Thing              | Convention                    | Example                          |
+| ------------------ | ----------------------------- | -------------------------------- |
+| Svelte component   | PascalCase                    | `AnalysisNode.svelte`            |
+| Svelte store file  | camelCase                     | `stores.js`                      |
+| CSS file           | kebab-case                    | `workflow.css`                   |
+| LiveView hook      | PascalCase (object key)       | `WorkflowHook`                   |
+| Custom event       | kebab-case                    | `node-selected`, `run-pipeline`  |
+| Data attribute     | kebab-case                    | `data-node-id`, `data-props`     |
+
+---
+
+## Do / Don't
+
+### Do
+
+- Use daisyUI component classes before building custom
+- Keep Svelte components focused and < 150 lines
+- Use semantic color tokens everywhere
+- Pass data from LiveView via `data-*` attributes
+- Use `gap-*` instead of margins between siblings
+- Test with both light and dark themes
+
+### Don't
+
+- Don't hardcode colors (`#fff`, `oklch(...)`, `gray-200`)
+- Don't use Svelte for things LiveView handles fine (forms, navigation)
+- Don't fight daisyUI — if it doesn't have the component, build with Tailwind utilities
+- Don't nest Svelte components more than 3 levels deep
+- Don't put business logic in Svelte — keep it in LiveView/Elixir
+- Don't use `@apply` in CSS files — inline Tailwind classes instead
diff --git a/apps/gitlock_cli/lib/argument_parser.ex b/apps/gitlock_cli/lib/argument_parser.ex
index 1c57687..4c32942 100644
--- a/apps/gitlock_cli/lib/argument_parser.ex
+++ b/apps/gitlock_cli/lib/argument_parser.ex
@@ -109,7 +109,19 @@ defmodule GitlockCLI.ArgumentParser do
   defp build_parsed_args(parsed_options, remaining_args) do
     case extract_investigation_info(parsed_options, remaining_args) do
       {:ok, investigation_type, args_without_investigation} ->
-        {repo_source, source_type} = RepositorySource.determine(parsed_options)
+        # Explicit --repo/--url/--log takes priority over positional args
+        {repo_source, source_type} =
+          if has_explicit_repo?(parsed_options) do
+            RepositorySource.determine(parsed_options)
+          else
+            case args_without_investigation do
+              [path | _] when byte_size(path) > 0 ->
+                {path, RepositorySource.determine_source_type(path)}
+
+              _ ->
+                RepositorySource.determine(parsed_options)
+            end
+          end
 
         processed_options =
           OptionProcessor.prepare_options(parsed_options, args_without_investigation)
@@ -127,6 +139,10 @@ defmodule GitlockCLI.ArgumentParser do
     end
   end
 
+  defp has_explicit_repo?(opts) do
+    opts[:repo] != nil || opts[:url] != nil || opts[:log] != nil
+  end
+
   # Extracts investigation type from arguments (supports both new and legacy styles)
   defp extract_investigation_info(options, remaining_args) do
     cond do
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/base_analyzer.ex b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/base_analyzer.ex
index d555895..cb1c313 100644
--- a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/base_analyzer.ex
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/base_analyzer.ex
@@ -165,8 +165,28 @@ defmodule GitlockCore.Adapters.Complexity.BaseAnalyzer do
                 non_neg_integer()
       end
 
+      @doc """
+      Analyzes complexity from a content string without reading from disk.
+
+      Used for historical analysis where file content comes from git.
+      """
+      @impl true
+      @spec analyze_content(String.t(), String.t()) :: {:ok, ComplexityMetrics.t()}
+      def analyze_content(content, file_path) do
+        metrics =
+          ComplexityMetrics.new(
+            file_path,
+            count_lines(content),
+            calculate_complexity(content, file_path),
+            detect_language(file_path)
+          )
+
+        {:ok, metrics}
+      end
+
       defoverridable analyze_file: 1
       defoverridable analyze_directory: 2
+      defoverridable analyze_content: 2
     end
   end
 end
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/dispatch_analyzer.ex b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/dispatch_analyzer.ex
index beac054..43ec47a 100644
--- a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/dispatch_analyzer.ex
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/dispatch_analyzer.ex
@@ -1,6 +1,6 @@
 defmodule GitlockCore.Adapters.Complexity.DispatchAnalyzer do
   @moduledoc """
-  A dispatch  analyzer that delegates to specific language analyzers based on file extensions.
+  A dispatch analyzer that delegates to specific language analyzers based on file extensions.
 
   This analyzer implements the ComplexityAnalyzerPort behavior but internally routes
   analysis requests to the appropriate language-specific analyzer based on file extension.
@@ -15,18 +15,27 @@ defmodule GitlockCore.Adapters.Complexity.DispatchAnalyzer do
   alias GitlockCore.Adapters.Complexity.Lang.{
     ElixirAnalyzer,
     JavaScriptAnalyzer,
+    TypeScriptAnalyzer,
     PythonAnalyzer,
     MockAnalyzer
   }
 
-  # Define all available analyzers
   @available_analyzers [
     ElixirAnalyzer,
     JavaScriptAnalyzer,
+    TypeScriptAnalyzer,
     PythonAnalyzer,
     MockAnalyzer
   ]
 
+  # Real analyzers (excludes MockAnalyzer which is a fallback)
+  @real_analyzers [
+    ElixirAnalyzer,
+    JavaScriptAnalyzer,
+    TypeScriptAnalyzer,
+    PythonAnalyzer
+  ]
+
   @impl true
   def supported_extensions() do
     @available_analyzers
@@ -42,10 +51,31 @@ defmodule GitlockCore.Adapters.Complexity.DispatchAnalyzer do
     analyzer.analyze_file(file_path)
   end
 
+  @doc """
+  Analyze complexity from file content directly, without reading from disk.
+
+  Used for historical analysis where file content comes from `git show`.
+  """
+  @impl true
+  def analyze_content(content, file_path) do
+    extension = Path.extname(file_path)
+
+    case find_real_analyzer(extension) do
+      nil -> {:error, :unsupported_language}
+      analyzer -> analyzer.analyze_content(content, file_path)
+    end
+  end
+
   defp select_analyzer(extension) do
     @available_analyzers
     |> Enum.find(MockAnalyzer, fn analyzer ->
       extension in analyzer.supported_extensions()
     end)
   end
+
+  defp find_real_analyzer(extension) do
+    Enum.find(@real_analyzers, fn analyzer ->
+      extension in analyzer.supported_extensions()
+    end)
+  end
 end
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/elixir_analyzer.ex b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/elixir_analyzer.ex
index 8f382a1..90ec64f 100644
--- a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/elixir_analyzer.ex
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/elixir_analyzer.ex
@@ -2,7 +2,8 @@ defmodule GitlockCore.Adapters.Complexity.Lang.ElixirAnalyzer do
   @moduledoc """
   Complexity analyzer for Elixir code.
   Calculates cyclomatic complexity by analyzing the AST for branching
-  statements (if, case, cond, with, etc.).
+  statements (if, case, cond, with, try/rescue, receive, multi-clause
+  functions, and boolean operators).
   """
   use GitlockCore.Adapters.Complexity.BaseAnalyzer
 
@@ -10,61 +11,47 @@ defmodule GitlockCore.Adapters.Complexity.Lang.ElixirAnalyzer do
 
   def calculate_complexity(content, file_path) do
     try do
-      # Handle the result from Code.string_to_quoted without pattern matching
       case Code.string_to_quoted(content) do
         {:ok, ast} ->
-          # Calculate complexity (starting at 1 for baseline)
-          complexity = 1 + count_complexity(ast)
-          complexity
+          1 + count_complexity(ast)
 
         {:error, {_line, _error, _token}} ->
-          # Log a simpler error message
           -1
       end
     rescue
       _e ->
-        # Use a more generic error message to avoid string conversion issues
         IO.warn("#{file_path}: Error analyzing code")
         -1
     end
   end
 
-  # Traverses the AST to count decision points
+  # --- Leaf nodes ---
   defp count_complexity(nil), do: 0
   defp count_complexity(expr) when not is_tuple(expr) and not is_list(expr), do: 0
 
-  # If statements add 1 complexity
-  defp count_complexity({:if, _, [condition, blocks]}) do
-    # Count the if statement itself
-    condition_complexity = count_complexity(condition)
-
-    # Extract do and else blocks
+  # --- if/unless ---
+  defp count_complexity({op, _, [condition, blocks]}) when op in [:if, :unless] do
     do_block = Keyword.get(blocks, :do, nil)
     else_block = Keyword.get(blocks, :else, nil)
 
-    # Count complexity in both branches
-    do_complexity = count_complexity(do_block)
-    else_complexity = count_complexity(else_block)
-
-    # Return total
-    1 + condition_complexity + do_complexity + else_complexity
+    1 +
+      count_complexity(condition) +
+      count_complexity(do_block) +
+      count_complexity(else_block)
   end
 
-  # Case expressions add 1 for each pattern match
+  # --- case ---
   defp count_complexity({:case, _, [expr, [do: clauses]]}) do
-    expr_complexity = count_complexity(expr)
-
-    # Count 1 for each clause plus complexity within each clause
     clauses_complexity =
       Enum.reduce(clauses, 0, fn
         {:->, _, [_pattern, body]}, acc ->
           acc + 1 + count_complexity(body)
       end)
 
-    expr_complexity + clauses_complexity
+    count_complexity(expr) + clauses_complexity
   end
 
-  # Cond statements add 1 for each condition
+  # --- cond ---
   defp count_complexity({:cond, _, [[do: clauses]]}) do
     Enum.reduce(clauses, 0, fn
       {:->, _, [[condition], body]}, acc ->
@@ -72,28 +59,143 @@ defmodule GitlockCore.Adapters.Complexity.Lang.ElixirAnalyzer do
     end)
   end
 
-  # Boolean operators add complexity
+  # --- with ---
+  defp count_complexity({:with, _, args}) when is_list(args) do
+    {clauses, blocks} = split_with_args(args)
+
+    clauses_complexity =
+      Enum.reduce(clauses, 0, fn
+        {:<-, _, [_pattern, expr]}, acc -> acc + 1 + count_complexity(expr)
+        expr, acc -> acc + count_complexity(expr)
+      end)
+
+    do_block = Keyword.get(blocks, :do, nil)
+    else_clauses = Keyword.get(blocks, :else, [])
+
+    else_complexity =
+      case else_clauses do
+        clauses when is_list(clauses) ->
+          Enum.reduce(clauses, 0, fn
+            {:->, _, [_pattern, body]}, acc -> acc + 1 + count_complexity(body)
+            _, acc -> acc
+          end)
+
+        other ->
+          count_complexity(other)
+      end
+
+    clauses_complexity + count_complexity(do_block) + else_complexity
+  end
+
+  # --- try/rescue/catch ---
+  defp count_complexity({:try, _, [[{:do, do_block} | rest]]}) do
+    rescue_complexity =
+      case Keyword.get(rest, :rescue) do
+        nil ->
+          0
+
+        clauses when is_list(clauses) ->
+          Enum.reduce(clauses, 0, fn
+            {:->, _, [_pattern, body]}, acc -> acc + 1 + count_complexity(body)
+            _, acc -> acc
+          end)
+      end
+
+    catch_complexity =
+      case Keyword.get(rest, :catch) do
+        nil ->
+          0
+
+        clauses when is_list(clauses) ->
+          Enum.reduce(clauses, 0, fn
+            {:->, _, [_pattern, body]}, acc -> acc + 1 + count_complexity(body)
+            _, acc -> acc
+          end)
+      end
+
+    after_block = Keyword.get(rest, :after, nil)
+
+    count_complexity(do_block) +
+      rescue_complexity +
+      catch_complexity +
+      count_complexity(after_block)
+  end
+
+  # --- receive ---
+  defp count_complexity({:receive, _, [blocks]}) when is_list(blocks) do
+    clauses = Keyword.get(blocks, :do, [])
+
+    clauses_complexity =
+      case clauses do
+        c when is_list(c) ->
+          Enum.reduce(c, 0, fn
+            {:->, _, [_pattern, body]}, acc -> acc + 1 + count_complexity(body)
+            _, acc -> acc
+          end)
+
+        other ->
+          count_complexity(other)
+      end
+
+    after_clauses = Keyword.get(blocks, :after, nil)
+
+    after_complexity =
+      case after_clauses do
+        nil ->
+          0
+
+        c when is_list(c) ->
+          Enum.reduce(c, 0, fn
+            {:->, _, [_pattern, body]}, acc -> acc + 1 + count_complexity(body)
+            _, acc -> acc
+          end)
+
+        other ->
+          count_complexity(other)
+      end
+
+    clauses_complexity + after_complexity
+  end
+
+  # --- Anonymous fn with multiple clauses ---
+  defp count_complexity({:fn, _, clauses}) when is_list(clauses) do
+    if length(clauses) > 1 do
+      # Multiple clauses = branching, count each
+      Enum.reduce(clauses, 0, fn
+        {:->, _, [_pattern, body]}, acc -> acc + 1 + count_complexity(body)
+      end)
+    else
+      # Single clause fn, just recurse into body
+      Enum.reduce(clauses, 0, fn
+        {:->, _, [_pattern, body]}, acc -> acc + count_complexity(body)
+      end)
+    end
+  end
+
+  # --- Boolean operators ---
   defp count_complexity({op, _, [left, right]}) when op in [:and, :or, :&&, :||] do
     1 + count_complexity(left) + count_complexity(right)
   end
 
-  # Function definitions
-  defp count_complexity({:def, _, [_head, [do: body]]}) do
-    count_complexity(body)
+  # --- Multi-clause named functions ---
+  # def/defp with when guards count the guard as a decision point
+  defp count_complexity({op, _, [{:when, _, [_head, _guard]}, [do: body]]})
+       when op in [:def, :defp] do
+    1 + count_complexity(body)
   end
 
-  defp count_complexity({:defp, _, [_head, [do: body]]}) do
+  defp count_complexity({op, _, [_head, [do: body]]}) when op in [:def, :defp] do
     count_complexity(body)
   end
 
-  # Recursively process nodes
+  # --- Generic AST node recursion ---
   defp count_complexity({_op, _meta, args}) when is_list(args) do
     Enum.reduce(args, 0, fn arg, acc ->
       acc + count_complexity(arg)
     end)
   end
 
-  # Handle lists (including keyword lists)
+  # --- Lists (including keyword lists) ---
   defp count_complexity(list) when is_list(list) do
     Enum.reduce(list, 0, fn
       {_key, value}, acc -> acc + count_complexity(value)
@@ -101,6 +203,20 @@ defmodule GitlockCore.Adapters.Complexity.Lang.ElixirAnalyzer do
     end)
   end
 
-  # Default for anything else
   defp count_complexity(_), do: 0
+
+  # --- Helpers ---
+
+  # Splits `with` args into match clauses and keyword blocks (do/else)
+  defp split_with_args(args) do
+    {clauses, blocks} =
+      Enum.split_while(args, fn
+        [{:do, _} | _] -> false
+        [do: _] -> false
+        _ -> true
+      end)
+
+    blocks = List.flatten(blocks)
+    {clauses, blocks}
+  end
 end
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/javascript_analyzer.ex b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/javascript_analyzer.ex
index 1b803d1..46fa50f 100644
--- a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/javascript_analyzer.ex
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/javascript_analyzer.ex
@@ -1,71 +1,71 @@
 defmodule GitlockCore.Adapters.Complexity.Lang.JavaScriptAnalyzer do
   @moduledoc """
   JavaScript complexity analyzer for CodeMaat-style forensic code analysis.
-  This analyzer calculates cyclomatic complexity for JavaScript files by counting:
+
+  Calculates cyclomatic complexity for JavaScript/TypeScript files by counting:
   - Conditional statements (if, switch-case, ternary)
   - Loops (for, while, do-while)
-  - Logical operations (&&, ||)
+  - Logical operations (&&, ||, ??)
   - Try-catch blocks
-  - Functions definitions (each function is a +1 baseline complexity)
-  It implements the ComplexityAnalyzerPort behavior using the BaseAnalyzer.
+  - Function definitions (each function adds +1 baseline)
+
+  Comments and string literals are stripped before analysis to prevent
+  false positives.
   """
   use GitlockCore.Adapters.Complexity.BaseAnalyzer
 
-  @doc """
-  Returns the file extensions this analyzer supports.
-  """
-  def supported_extensions, do: [".js", ".jsx", ".ts", ".tsx"]
+  def supported_extensions, do: [".js", ".jsx"]
 
-  # Calculates cyclomatic complexity for JavaScript code.
-  #
-  # The calculation is based on counting control flow branches:
-  # - Each function gets a base complexity of 1
-  # - Each 'if', 'else if', 'switch case', 'for', 'while', etc. adds 1
-  # - Each '&&', '||' in conditions adds 1
-  # - Each 'catch' block adds 1
-  #
-  # ## Parameters
-  #   * `content` - JavaScript code as string
-  #   * `file_path` - Path to the source file (used for error reporting)
-  #
-  # ## Returns
-  #   A non-negative integer representing the cyclomatic complexity
   defp calculate_complexity(content, _file_path) do
-    # Calculate base complexity - start with 1 for the program itself
+    cleaned = clean_js_content(content)
+
     base_complexity = 1
 
-    # Define all patterns to search for
     patterns = [
       if: ~r/\bif\s*\(/,
       else_if: ~r/\belse\s+if\s*\(/,
-      ternary: ~r/\?\s*[^:]+\s*:/,
       for: ~r/\bfor\s*\(/,
       while: ~r/\bwhile\s*\(/,
       do_while: ~r/\bdo\s*\{/,
-      function1: ~r/\bfunction\s+[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
-      function2: ~r/\b(const|let|var)\s+[a-zA-Z_$][a-zA-Z0-9_$]*\s*=\s*function\s*\(/,
-      function3: ~r/\b(const|let|var)\s+[a-zA-Z_$][a-zA-Z0-9_$]*\s*=\s*\([^)]*\)\s*=>/,
       case: ~r/\bcase\s+[^:]+:/,
-      logical_ops: ~r/\s+&&\s+|\s+\|\|\s+/,
-      catch: ~r/\bcatch\s*\(/
+      catch: ~r/\bcatch\s*[\(\{]/,
+      logical_and: ~r/&&/,
+      logical_or: ~r/\|\|/,
+      nullish: ~r/\?\?(?!=)/,
+      ternary: ~r/[^?]\?[^?.]/,
+      function_decl: ~r/\bfunction\s+\w+\s*\(/,
+      function_expr: ~r/\b(?:const|let|var)\s+\w+\s*=\s*function\s*\(/,
+      arrow_fn: ~r/(?:=>)/
     ]
 
-    # Run all regex scans in parallel and collect results
     complexity_counts =
       Task.async_stream(
         patterns,
         fn {_name, pattern} ->
-          count_regex(content, pattern)
+          count_regex(cleaned, pattern)
         end,
         on_timeout: :kill_task
       )
       |> Enum.reduce(0, fn {:ok, count}, acc -> acc + count end)
 
-    # Calculate the total cyclomatic complexity
     base_complexity + complexity_counts
   end
 
-  @spec count_regex(String.t(), Regex.t()) :: non_neg_integer()
+  # Strip comments and string literals to avoid false positives.
+  defp clean_js_content(content) do
+    content
+    # Remove single-line comments
+    |> String.replace(~r|//.*$|m, "")
+    # Remove multi-line comments
+    |> String.replace(~r|/\*[\s\S]*?\*/|, "")
+    # Remove template literals (backtick strings)
+    |> String.replace(~r/`(?:[^`\\]|\\.)*`/s, "\"\"")
+    # Remove double-quoted strings
+    |> String.replace(~r/"(?:[^"\\]|\\.)*"/, "\"\"")
+    # Remove single-quoted strings
+    |> String.replace(~r/'(?:[^'\\]|\\.)*'/, "''")
+  end
+
   defp count_regex(content, pattern) do
     Regex.scan(pattern, content) |> length()
   end
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/python_analyzer.ex b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/python_analyzer.ex
index 9370398..6629d4b 100644
--- a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/python_analyzer.ex
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/python_analyzer.ex
@@ -74,8 +74,8 @@ defmodule GitlockCore.Adapters.Complexity.Lang.PythonAnalyzer do
 
       # Comprehensions with conditions
       list_comp_if: ~r/\[\s*[^]]+\s+if\s+[^]]+\]/,
-      dict_comp_if: ~r/\{\s*[^}]+\s+if\s+[^}]+\}/,
-      set_comp_if: ~r/\{\s*[^}]+\s+if\s+[^}]+\}/,
+      dict_comp_if: ~r/\{\s*\w+\s*:\s*[^}]+\s+if\s+[^}]+\}/,
+      set_comp_if: ~r/\{\s*[^:}]+\s+for\s+[^}]+\s+if\s+[^}]+\}/,
       gen_exp_if: ~r/\(\s*[^)]+\s+if\s+[^)]+\)/,
 
       # Lambda with conditions (rough approximation)
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/typescript_analyzer.ex b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/typescript_analyzer.ex
new file mode 100644
index 0000000..2200941
--- /dev/null
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/complexity/lang/typescript_analyzer.ex
@@ -0,0 +1,101 @@
+defmodule GitlockCore.Adapters.Complexity.Lang.TypeScriptAnalyzer do
+  @moduledoc """
+  TypeScript complexity analyzer for Gitlock forensic code analysis.
+
+  Builds on JavaScript patterns but handles TypeScript-specific concerns:
+  - Strips type annotations, interfaces, and type aliases before analysis
+    to prevent false positives (e.g. conditional types `T extends U ? X : Y`
+    matching the ternary regex)
+  - Counts optional chaining `?.` as a branch point
+  - Counts type guard functions as decision points
+  - Handles decorators, enums, and other TS syntax
+
+  Comments, string literals, and type-only constructs are stripped before
+  analysis to ensure accurate results.
+  """
+  use GitlockCore.Adapters.Complexity.BaseAnalyzer
+
+  def supported_extensions, do: [".ts", ".tsx"]
+
+  defp calculate_complexity(content, _file_path) do
+    cleaned =
+      content
+      |> strip_comments_and_strings()
+      |> strip_type_constructs()
+
+    base_complexity = 1
+
+    patterns = [
+      # --- JS patterns (TS is a superset) ---
+      if: ~r/\bif\s*\(/,
+      else_if: ~r/\belse\s+if\s*\(/,
+      for: ~r/\bfor\s*\(/,
+      while: ~r/\bwhile\s*\(/,
+      do_while: ~r/\bdo\s*\{/,
+      case: ~r/\bcase\s+[^:]+:/,
+      catch: ~r/\bcatch\s*[\(\{]/,
+      logical_and: ~r/&&/,
+      logical_or: ~r/\|\|/,
+      nullish: ~r/\?\?(?!=)/,
+      ternary: ~r/[^?]\?[^?.]/,
+      function_decl: ~r/\bfunction\s+\w+\s*[\(<]/,
+      function_expr: ~r/\b(?:const|let|var)\s+\w+\s*(?::\s*\w[^=]*)?\s*=\s*function\s*[\(<]/,
+      arrow_fn: ~r/=>/,
+
+      # --- TypeScript-specific ---
+      # Optional chaining is a branch (short-circuits on null/undefined)
+      optional_chain: ~r/\?\.\s*[\w\[(]/,
+      # Type guard functions: `function isX(val): val is Type`
+      type_guard: ~r/\)\s*:\s*\w+\s+is\s+\w+/
+    ]
+
+    complexity_counts =
+      Task.async_stream(
+        patterns,
+        fn {_name, pattern} ->
+          Regex.scan(pattern, cleaned) |> length()
+        end,
+        on_timeout: :kill_task
+      )
+      |> Enum.reduce(0, fn {:ok, count}, acc -> acc + count end)
+
+    base_complexity + complexity_counts
+  end
+
+  # Strip comments and string literals to avoid false positives.
+  # Same as JS analyzer — TS uses identical comment/string syntax.
+  defp strip_comments_and_strings(content) do
+    content
+    |> String.replace(~r|//.*$|m, "")
+    |> String.replace(~r|/\*[\s\S]*?\*/|, "")
+    |> String.replace(~r/`(?:[^`\\]|\\.)*`/s, "\"\"")
+    |> String.replace(~r/"(?:[^"\\]|\\.)*"/, "\"\"")
+    |> String.replace(~r/'(?:[^'\\]|\\.)*'/, "''")
+  end
+
+  # Strip TypeScript type-only constructs that could cause false positives.
+  #
+  # Key problem: conditional types like `T extends U ? X : Y` contain `?`
+  # which would falsely match the ternary regex. Interface/type declarations
+  # can also contain patterns that look like runtime branches.
+  defp strip_type_constructs(content) do
+    content
+    # Remove full interface declarations (multi-line)
+    |> String.replace(~r/\binterface\s+\w+(?:\s+extends\s+[^{]+)?\s*\{[^}]*\}/s, "")
+    # Remove type alias declarations (handles multi-line conditional types)
+    |> String.replace(~r/\btype\s+\w+(?:<[^>]*>)?\s*=\s*[^;]+;/s, "")
+    # Remove type annotations after `:` in params/returns
+    # e.g. `(x: number, y: string): boolean` → `(x, y)`
+    # IMPORTANT: must NOT include `{` or `}` — those delimit code blocks,
+    # not just inline object types. Matching them eats function bodies.
+    |> String.replace(~r/:\s*(?:readonly\s+)?[\w<>\[\]|&\s,.]+(?=\s*[,)=>{])/s, "")
+    # Remove angle-bracket generics `<T extends Foo>` to avoid `extends` noise
+    |> String.replace(~r/<[^>]*>/s, "")
+    # Remove `as` type assertions: `x as Type`
+    |> String.replace(~r/\bas\s+\w[\w.]*(?:\[\])?/s, "")
+    # Remove `declare` statements (ambient declarations)
+    |> String.replace(~r/\bdeclare\s+[^;{]+[;{]/s, "")
+    # Remove `enum` declarations (members aren't branches)
+    |> String.replace(~r/\benum\s+\w+\s*\{[^}]*\}/s, "")
+  end
+end
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/reporters/stdout_reporter.ex b/apps/gitlock_core/lib/gitlock_core/adapters/reporters/stdout_reporter.ex
index 7766b6b..0d6004b 100644
--- a/apps/gitlock_core/lib/gitlock_core/adapters/reporters/stdout_reporter.ex
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/reporters/stdout_reporter.ex
@@ -282,10 +282,14 @@ defmodule GitlockCore.Adapters.Reporters.StdoutReporter do
         _ -> "⚪ Unknown Risk"
       end
 
+    normalized = get_field(hotspot, :normalized_score, 0.0)
+    percentile = get_field(hotspot, :percentile, 0.0)
+    top_pct = Float.round(100.0 - percentile, 1)
+
     """
     #{risk_emoji}: #{get_field(hotspot, :entity)}
+    • Score: #{format_float(normalized)}/100 (top #{format_float(top_pct)}% riskiest)
     • #{get_field(hotspot, :revisions)} changes, complexity: #{get_field(hotspot, :complexity)}, #{format_number(get_field(hotspot, :loc))} lines
-    • Risk score: #{format_float(get_field(hotspot, :risk_score))}
     """
     |> String.trim()
   end
diff --git a/apps/gitlock_core/lib/gitlock_core/adapters/vcs/git.ex b/apps/gitlock_core/lib/gitlock_core/adapters/vcs/git.ex
index 59e065e..c638d9b 100644
--- a/apps/gitlock_core/lib/gitlock_core/adapters/vcs/git.ex
+++ b/apps/gitlock_core/lib/gitlock_core/adapters/vcs/git.ex
@@ -14,6 +14,7 @@ defmodule GitlockCore.Adapters.VCS.Git do
   def get_commit_history(source, options \\ %{}) do
     Logger.debug("Getting commit history from #{source}")
 
+    # Pass through progress_fn if provided
     case GitRepository.fetch_log(source, options) do
       {:ok, log_content} ->
         parse_git_log(log_content)
@@ -278,4 +279,36 @@ defmodule GitlockCore.Adapters.VCS.Git do
         nil
     end
   end
+
+  # ── File-at-commit operations ────────────────────────────────
+
+  @impl true
+  def get_file_at_commit(repo_path, commit_id, file_path) do
+    case System.cmd("git", ["show", "#{commit_id}:#{file_path}"],
+           cd: repo_path,
+           stderr_to_stdout: true
+         ) do
+      {content, 0} -> {:ok, content}
+      {output, _} -> {:error, {:file_not_found, file_path, String.trim(output)}}
+    end
+  rescue
+    e -> {:error, {:git_error, Exception.message(e)}}
+  end
+
+  @impl true
+  def list_files_at_commit(repo_path, commit_id) do
+    case System.cmd("git", ["ls-tree", "-r", "--name-only", commit_id],
+           cd: repo_path,
+           stderr_to_stdout: true
+         ) do
+      {output, 0} ->
+        files = output |> String.split("\n", trim: true)
+        {:ok, files}
+
+      {output, _} ->
+        {:error, {:git_error, String.trim(output)}}
+    end
+  rescue
+    e -> {:error, {:git_error, Exception.message(e)}}
+  end
 end
diff --git a/apps/gitlock_core/lib/gitlock_core/domain/services/complexity_trend_analysis.ex b/apps/gitlock_core/lib/gitlock_core/domain/services/complexity_trend_analysis.ex
new file mode 100644
index 0000000..e84b9fa
--- /dev/null
+++ b/apps/gitlock_core/lib/gitlock_core/domain/services/complexity_trend_analysis.ex
@@ -0,0 +1,178 @@
+defmodule GitlockCore.Domain.Services.ComplexityTrendAnalysis do
+  @moduledoc """
+  Analyzes complexity trends over time for hotspot files.
+
+  This is the "X-Ray" from Tornhill's Software Design X-Rays:
+  instead of a single complexity snapshot, it reveals how complexity
+  has evolved — whether a hotspot is stable, growing, or improving.
+
+  The analysis works by:
+  1. Identifying the top N hotspot files
+  2. Sampling commits at regular intervals across the repository history
+  3. Retrieving file content at each sample point via `git show`
+  4. Running complexity analysis on each historical version
+  5. Producing a time series per file showing the trajectory
+
+  ## Sampling strategy
+
+  Rather than analyzing every commit (prohibitively expensive), we sample
+  at monthly intervals. For a 2-year history with 15 files, this yields
+  ~24 × 15 = 360 complexity calculations — completing in seconds.
+  """
+
+  alias GitlockCore.Domain.Values.{ComplexityTrend, Hotspot}
+  alias GitlockCore.Domain.Services.HotspotDetection
+  alias GitlockCore.Domain.Entities.Commit
+  alias GitlockCore.Infrastructure.GitRepository
+  alias GitlockCore.Adapters.Complexity.DispatchAnalyzer
+
+  require Logger
+
+  @default_max_files 15
+  @default_interval_days 30
+
+  # File extensions that have real complexity analyzers
+  @analyzable_extensions [".ex", ".exs", ".js", ".jsx", ".ts", ".tsx", ".py"]
+
+  @type option ::
+          {:max_files, pos_integer()}
+          | {:interval_days, pos_integer()}
+          | {:progress_fn, (String.t() -> :ok)}
+
+  @doc """
+  Analyzes complexity trends for the hottest files in a repository.
+
+  ## Parameters
+    * `commits` - Parsed commit history
+    * `repo_path` - Path to the git repository (for `git show`)
+    * `opts` - Options:
+      * `:max_files` - Number of hotspot files to analyze (default: #{@default_max_files})
+      * `:interval_days` - Days between sample points (default: #{@default_interval_days})
+      * `:progress_fn` - Optional callback for status updates
+
+  ## Returns
+    List of `%ComplexityTrend{}` sorted by absolute complexity change (biggest movers first)
+  """
+  @spec analyze([Commit.t()], String.t(), [option()]) :: [ComplexityTrend.t()]
+  def analyze(commits, repo_path, opts \\ []) do
+    max_files = Keyword.get(opts, :max_files, @default_max_files)
+    interval_days = Keyword.get(opts, :interval_days, @default_interval_days)
+    progress_fn = Keyword.get(opts, :progress_fn, fn _ -> :ok end)
+
+    # 1. Find top hotspot files, filtered to analyzable languages
+    hotspots =
+      commits
+      |> HotspotDetection.detect_hotspots()
+      |> filter_analyzable()
+      |> Enum.take(max_files)
+
+    if hotspots == [] do
+      []
+    else
+      progress_fn.("Analyzing trends for #{length(hotspots)} hotspot files")
+
+      # 2. Build sample dates
+      sample_dates = build_sample_dates(commits, interval_days)
+      progress_fn.("Sampling #{length(sample_dates)} time points")
+
+      # 3. Resolve sample dates to commit SHAs
+      sample_revisions = resolve_sample_revisions(repo_path, sample_dates)
+
+      # 4. For each file, collect complexity at each sample point
+      hotspots
+      |> Enum.with_index()
+      |> Enum.map(fn {%Hotspot{entity: entity}, idx} ->
+        progress_fn.("X-ray #{idx + 1}/#{length(hotspots)}: #{Path.basename(entity)}")
+        points = collect_file_trend(repo_path, entity, sample_revisions)
+        ComplexityTrend.from_points(entity, points)
+      end)
+      |> Enum.filter(fn trend -> trend.num_samples >= 2 end)
+      |> Enum.sort_by(fn trend -> abs(trend.complexity_change) end, :desc)
+    end
+  end
+
+  @doc """
+  Builds a list of sample dates spanning the commit history at regular intervals.
+  """
+  @spec build_sample_dates([Commit.t()], pos_integer()) :: [Date.t()]
+  def build_sample_dates(commits, interval_days) do
+    dates = Enum.map(commits, & &1.date) |> Enum.sort(Date)
+    earliest = List.first(dates)
+    latest = List.last(dates)
+
+    if earliest == nil or latest == nil or Date.compare(earliest, latest) == :eq do
+      if latest, do: [latest], else: []
+    else
+      build_date_series(earliest, latest, interval_days)
+    end
+  end
+
+  # ── Private ──────────────────────────────────────────────────
+
+  defp filter_analyzable(hotspots) do
+    Enum.filter(hotspots, fn %Hotspot{entity: entity} ->
+      Path.extname(entity) in @analyzable_extensions
+    end)
+  end
+
+  defp build_date_series(from, to, interval_days) do
+    Stream.unfold(from, fn current ->
+      if Date.compare(current, to) == :gt do
+        nil
+      else
+        {current, Date.add(current, interval_days)}
+      end
+    end)
+    |> Enum.to_list()
+    |> then(fn dates ->
+      # Always include the latest date if not already there
+      if List.last(dates) != to, do: dates ++ [to], else: dates
+    end)
+  end
+
+  defp resolve_sample_revisions(repo_path, sample_dates) do
+    sample_dates
+    |> Enum.map(fn date ->
+      case GitRepository.commit_at_date(repo_path, date) do
+        {:ok, sha} -> {date, sha}
+        {:error, _} -> nil
+      end
+    end)
+    |> Enum.reject(&is_nil/1)
+    |> Enum.uniq_by(fn {_date, sha} -> sha end)
+  end
+
+  defp collect_file_trend(repo_path, file_path, sample_revisions) do
+    sample_revisions
+    |> Enum.map(fn {date, sha} ->
+      case analyze_file_at_revision(repo_path, sha, file_path) do
+        {:ok, metrics} ->
+          %{
+            date: date,
+            revision: sha,
+            complexity: metrics.cyclomatic_complexity,
+            loc: metrics.loc
+          }
+
+        {:error, _} ->
+          # File didn't exist at this revision or unsupported — skip
+          nil
+      end
+    end)
+    |> Enum.reject(&is_nil/1)
+  end
+
+  defp analyze_file_at_revision(repo_path, sha, file_path) do
+    with {:ok, content} <- GitRepository.file_at_revision(repo_path, sha, file_path),
+         {:ok, metrics} <- DispatchAnalyzer.analyze_content(content, file_path) do
+      {:ok, metrics}
+    end
+  rescue
+    e ->
+      Logger.debug(
+        "Complexity analysis failed for #{file_path}@#{String.slice(sha, 0..7)}: #{Exception.message(e)}"
+      )
+
+      {:error, :analysis_failed}
+  end
+end
diff --git a/apps/gitlock_core/lib/gitlock_core/domain/services/hotspot_detection.ex b/apps/gitlock_core/lib/gitlock_core/domain/services/hotspot_detection.ex
index 67e4493..c95b7d8 100644
--- a/apps/gitlock_core/lib/gitlock_core/domain/services/hotspot_detection.ex
+++ b/apps/gitlock_core/lib/gitlock_core/domain/services/hotspot_detection.ex
@@ -25,27 +25,84 @@ defmodule GitlockCore.Domain.Services.HotspotDetection do
       |> Enum.flat_map(fn %Commit{file_changes: changes} -> changes end)
 
     # Group by entity (file path) and count revisions
-    file_changes
-    |> Enum.group_by(fn %FileChange{entity: entity} -> entity end)
-    |> Enum.map(fn {entity, changes} ->
-      # Get complexity metrics if available
-      metrics = Map.get(complexity_metrics, entity)
-      complexity = if metrics, do: metrics.cyclomatic_complexity, else: 1
-      loc = if metrics, do: metrics.loc, else: 0
-
-      # Calculate risk based on both change frequency and complexity
-      risk_score = calculate_risk_score(changes, complexity, loc)
-
-      %Hotspot{
-        entity: entity,
-        revisions: length(changes),
-        complexity: complexity,
-        loc: loc,
-        risk_score: risk_score,
-        risk_factor: risk_level_from_score(risk_score)
+    hotspots =
+      file_changes
+      |> Enum.group_by(fn %FileChange{entity: entity} -> entity end)
+      |> Enum.map(fn {entity, changes} ->
+        # Get complexity metrics if available
+        metrics = Map.get(complexity_metrics, entity)
+        complexity = if metrics, do: metrics.cyclomatic_complexity, else: 1
+        loc = if metrics, do: metrics.loc, else: 0
+
+        # Calculate risk based on both change frequency and complexity
+        risk_score = calculate_risk_score(changes, complexity, loc)
+
+        %Hotspot{
+          entity: entity,
+          revisions: length(changes),
+          complexity: complexity,
+          loc: loc,
+          risk_score: risk_score,
+          risk_factor: :low
+        }
+      end)
+      |> Enum.sort_by(fn %{risk_score: score} -> score end, :desc)
+
+    normalize_scores(hotspots)
+  end
+
+  @doc """
+  Normalizes raw risk scores to 0-100 scale and calculates percentiles.
+
+  Uses min-max normalization on log-scaled scores to prevent extreme outliers
+  from compressing the rest of the distribution.
+  """
+  @spec normalize_scores([Hotspot.t()]) :: [Hotspot.t()]
+  def normalize_scores([]), do: []
+
+  def normalize_scores([single] = _hotspots) do
+    [
+      %{
+        single
+        | normalized_score: 100.0,
+          percentile: 100.0,
+          risk_factor: risk_level_from_normalized(100.0)
+      }
+    ]
+  end
+
+  def normalize_scores(hotspots) do
+    total = length(hotspots)
+
+    # Use log scale to prevent outliers from compressing the distribution
+    log_scores = Enum.map(hotspots, fn h -> :math.log(h.risk_score + 1) end)
+    min_log = Enum.min(log_scores)
+    max_log = Enum.max(log_scores)
+    range = max_log - min_log
+
+    hotspots
+    |> Enum.with_index()
+    |> Enum.map(fn {hotspot, rank} ->
+      # Normalized score: 0-100 via min-max on log scale
+      normalized =
+        if range == 0 do
+          50.0
+        else
+          log_score = :math.log(hotspot.risk_score + 1)
+          (log_score - min_log) / range * 100.0
+        end
+
+      # Percentile: what percentage of files score lower than this one
+      # rank 0 = highest score = highest percentile
+      percentile = (total - rank - 1) / max(total - 1, 1) * 100.0
+
+      %{
+        hotspot
+        | normalized_score: Float.round(normalized, 1),
+          percentile: Float.round(percentile, 1),
+          risk_factor: risk_level_from_normalized(normalized)
       }
     end)
-    |> Enum.sort_by(fn %{risk_score: score} -> score end, :desc)
   end
 
   @doc """
@@ -72,8 +129,18 @@ defmodule GitlockCore.Domain.Services.HotspotDetection do
   end
 
   @doc """
-  Determines risk level based on calculated score.
+  Determines risk level based on normalized 0-100 score.
+
+  - High: top 20% (score > 70)
+  - Medium: middle tier (score > 40)
+  - Low: bottom tier
   """
+  @spec risk_level_from_normalized(float()) :: Hotspot.risk_factor()
+  def risk_level_from_normalized(score) when score > 70.0, do: :high
+  def risk_level_from_normalized(score) when score > 40.0, do: :medium
+  def risk_level_from_normalized(_), do: :low
+
+  # Keep for backward compatibility
   @spec risk_level_from_score(float()) :: Hotspot.risk_factor()
   def risk_level_from_score(score) when score > 2.0, do: :high
   def risk_level_from_score(score) when score > 1.0, do: :medium
diff --git a/apps/gitlock_core/lib/gitlock_core/domain/values/complexity_metrics.ex b/apps/gitlock_core/lib/gitlock_core/domain/values/complexity_metrics.ex
index 682e9b5..d5b9ccb 100644
--- a/apps/gitlock_core/lib/gitlock_core/domain/values/complexity_metrics.ex
+++ b/apps/gitlock_core/lib/gitlock_core/domain/values/complexity_metrics.ex
@@ -6,7 +6,7 @@ defmodule GitlockCore.Domain.Values.ComplexityMetrics do
   measurements for a specific file.
   """
 
-  @type language :: :elixir | :javascript | :ruby | :python | :java | :unknown
+  @type language :: :elixir | :javascript | :typescript | :ruby | :python | :java | :unknown
 
   @type t :: %__MODULE__{
           file_path: String.t(),
diff --git a/apps/gitlock_core/lib/gitlock_core/domain/values/complexity_trend.ex b/apps/gitlock_core/lib/gitlock_core/domain/values/complexity_trend.ex
new file mode 100644
index 0000000..5b1b5c7
--- /dev/null
+++ b/apps/gitlock_core/lib/gitlock_core/domain/values/complexity_trend.ex
@@ -0,0 +1,98 @@
+defmodule GitlockCore.Domain.Values.ComplexityTrend do
+  @moduledoc """
+  Represents the complexity trajectory of a file over time.
+
+  Each trend contains a series of data points showing how a file's
+  complexity and size have evolved. The trend direction and magnitude
+  indicate whether the file is getting harder to maintain.
+  """
+
+  @type data_point :: %{
+          date: Date.t(),
+          revision: String.t(),
+          complexity: non_neg_integer(),
+          loc: non_neg_integer()
+        }
+
+  @type direction :: :rising | :stable | :declining
+
+  @type t :: %__MODULE__{
+          entity: String.t(),
+          points: [data_point()],
+          direction: direction(),
+          complexity_change: float(),
+          complexity_start: non_neg_integer(),
+          complexity_end: non_neg_integer(),
+          loc_change: float(),
+          num_samples: non_neg_integer()
+        }
+
+  @enforce_keys [:entity]
+  defstruct [
+    :entity,
+    points: [],
+    direction: :stable,
+    complexity_change: 0.0,
+    complexity_start: 0,
+    complexity_end: 0,
+    loc_change: 0.0,
+    num_samples: 0
+  ]
+
+  @doc """
+  Creates a ComplexityTrend from a list of data points.
+
+  Calculates direction and change metrics from the points.
+  """
+  @spec from_points(String.t(), [data_point()]) :: t()
+  def from_points(entity, []) do
+    %__MODULE__{entity: entity}
+  end
+
+  def from_points(entity, points) when length(points) == 1 do
+    [p] = points
+
+    %__MODULE__{
+      entity: entity,
+      points: points,
+      direction: :stable,
+      complexity_change: 0.0,
+      complexity_start: p.complexity,
+      complexity_end: p.complexity,
+      loc_change: 0.0,
+      num_samples: 1
+    }
+  end
+
+  def from_points(entity, points) do
+    sorted = Enum.sort_by(points, & &1.date, Date)
+    first = List.first(sorted)
+    last = List.last(sorted)
+
+    complexity_change = percentage_change(first.complexity, last.complexity)
+    loc_change = percentage_change(first.loc, last.loc)
+    direction = classify_direction(complexity_change)
+
+    %__MODULE__{
+      entity: entity,
+      points: sorted,
+      direction: direction,
+      complexity_change: Float.round(complexity_change, 1),
+      complexity_start: first.complexity,
+      complexity_end: last.complexity,
+      loc_change: Float.round(loc_change, 1),
+      num_samples: length(sorted)
+    }
+  end
+
+  defp percentage_change(0, 0), do: 0.0
+  defp percentage_change(0, _to), do: 100.0
+
+  defp percentage_change(from, to) do
+    (to - from) / from * 100.0
+  end
+
+  defp classify_direction(change) when change > 15.0, do: :rising
+  defp classify_direction(change) when change < -15.0, do: :declining
+  defp classify_direction(_), do: :stable
+end
diff --git a/apps/gitlock_core/lib/gitlock_core/domain/values/hotspot.ex b/apps/gitlock_core/lib/gitlock_core/domain/values/hotspot.ex
index ab9f9c5..9d5218a 100644
--- a/apps/gitlock_core/lib/gitlock_core/domain/values/hotspot.ex
+++ b/apps/gitlock_core/lib/gitlock_core/domain/values/hotspot.ex
@@ -26,10 +26,21 @@ defmodule GitlockCore.Domain.Values.Hotspot do
           complexity: non_neg_integer(),
           loc: non_neg_integer(),
           risk_factor: risk_factor(),
-          risk_score: float()
+          risk_score: float(),
+          normalized_score: float(),
+          percentile: float()
         }
 
-  defstruct [:entity, :revisions, :complexity, :loc, :risk_factor, :risk_score]
+  defstruct [
+    :entity,
+    :revisions,
+    :complexity,
+    :loc,
+    :risk_factor,
+    :risk_score,
+    normalized_score: 0.0,
+    percentile: 0.0
+  ]
 
   @doc """
   Creates a new hotspot value object.
@@ -45,14 +56,16 @@ defmodule GitlockCore.Domain.Values.Hotspot do
   ## Returns
     A new immutable Hotspot struct
   """
-  def new(entity, revisions, complexity, loc, risk_factor, risk_score) do
+  def new(entity, revisions, complexity, loc, risk_factor, risk_score, opts \\ []) do
     %__MODULE__{
       entity: entity,
       revisions: revisions,
       complexity: complexity,
       loc: loc,
       risk_factor: risk_factor,
-      risk_score: risk_score
+      risk_score: risk_score,
+      normalized_score: Keyword.get(opts, :normalized_score, 0.0),
+      percentile: Keyword.get(opts, :percentile, 0.0)
     }
   end
 
@@ -90,6 +103,8 @@ defmodule GitlockCore.Domain.Values.Hotspot do
       end
 
     "#{Path.basename(hotspot.entity)}: #{hotspot.revisions} revisions, " <>
-      "complexity: #{hotspot.complexity}, risk score: #{Float.round(hotspot.risk_score, 2)} (#{risk_text})"
+      "complexity: #{hotspot.complexity}, " <>
+      "score: #{Float.round(hotspot.normalized_score, 1)}/100 " <>
+      "(top #{Float.round(100.0 - hotspot.percentile, 1)}%) (#{risk_text})"
   end
 end
diff --git a/apps/gitlock_core/lib/gitlock_core/infrastructure/git_repository.ex b/apps/gitlock_core/lib/gitlock_core/infrastructure/git_repository.ex
index b777854..17d979b 100644
--- a/apps/gitlock_core/lib/gitlock_core/infrastructure/git_repository.ex
+++ b/apps/gitlock_core/lib/gitlock_core/infrastructure/git_repository.ex
@@ -21,8 +21,15 @@ defmodule GitlockCore.Infrastructure.GitRepository do
   Fetch raw git log output from a git repository.
 
   Automatically caches git logs for workspace-managed repositories.
+
+  ## Options
+
+    * `:progress_fn` - Optional `fn(message :: String.t()) -> :ok` for status updates
   """
   def fetch_log(repo_path, options \\ %{}) do
+    progress_fn = Map.get(options, :progress_fn, fn _ -> :ok end)
+    git_options = Map.delete(options, :progress_fn)
+
     # Check if this repo is managed by a workspace (and thus cacheable)
     workspace =
       Store.list()
@@ -33,28 +40,29 @@ defmodule GitlockCore.Infrastructure.GitRepository do
         # Get fresh workspace data from store to ensure we have latest cache
         workspace_data = Store.get(workspace_id)
         cache = workspace_data[:git_log_cache] || %{}
-        fetch_with_cache(workspace_id, repo_path, options, cache)
+        fetch_with_cache(workspace_id, repo_path, git_options, cache, progress_fn)
 
       _ ->
         # No workspace, generate without caching
-        generate_git_log(repo_path, options)
+        generate_git_log(repo_path, git_options, progress_fn)
     end
   end
 
   # Private Functions
 
-  defp fetch_with_cache(workspace_id, repo_path, options, cache_map) do
+  defp fetch_with_cache(workspace_id, repo_path, options, cache_map, progress_fn) do
     options_hash = hash_options(options)
     cache_path = Map.get(cache_map, options_hash)
 
     with {:cached, path} when is_binary(path) <- {:cached, cache_path},
          {:ok, log} <- File.read(path) do
       Logger.info("Using cached git log from #{path}")
+      progress_fn.("Using cached git log")
       {:ok, log}
     else
       _ ->
         # Generate and cache
-        with {:ok, log} <- generate_git_log(repo_path, options) do
+        with {:ok, log} <- generate_git_log(repo_path, options, progress_fn) do
           cache_path = build_cache_path(workspace_id, options_hash)
 
           case save_log_to_cache(cache_path, log) do
@@ -71,8 +79,11 @@ defmodule GitlockCore.Infrastructure.GitRepository do
     end
   end
 
-  defp generate_git_log(repo_path, options) do
+  defp generate_git_log(repo_path, options, progress_fn) do
     cond do
+      remote_url?(repo_path) ->
+        generate_from_remote(repo_path, options, progress_fn)
+
       not File.exists?(repo_path) ->
         {:error, "Git log failed (2): No such file or directory"}
 
@@ -80,16 +91,78 @@ defmodule GitlockCore.Infrastructure.GitRepository do
         {:error, "Git log failed (20): Not a directory"}
 
       true ->
-        Logger.debug("Generating git log from repo: #{repo_path}")
-        cmd_args = build_log_command(options)
+        progress_fn.("Reading git log...")
+        run_git_log(repo_path, options)
+    end
+  end
 
-        case System.cmd("git", cmd_args, cd: repo_path, stderr_to_stdout: true) do
-          {output, 0} -> {:ok, output}
-          {error, code} -> {:error, "Git log failed (#{code}): #{error}"}
-        end
+  defp run_git_log(local_path, options) do
+    Logger.debug("Generating git log from repo: #{local_path}")
+    cmd_args = build_log_command(options)
+
+    case System.cmd("git", cmd_args, cd: local_path, stderr_to_stdout: true) do
+      {output, 0} -> {:ok, output}
+      {error, code} -> {:error, "Git log failed (#{code}): #{error}"}
+    end
+  end
+
+  defp remote_url?(path) do
+    String.starts_with?(path, "https://") or
+      String.starts_with?(path, "http://") or
+      String.starts_with?(path, "git@") or
+      String.starts_with?(path, "ssh://")
+  end
+
+  defp generate_from_remote(url, options, progress_fn) do
+    clone_dir = clone_path_for(url)
+    repo_name = url |> String.split("/") |> Enum.take(-2) |> Enum.join("/")
+
+    if File.dir?(Path.join(clone_dir, ".git")) do
+      progress_fn.("Fetching updates for #{repo_name}...")
+      Logger.info("Using existing clone at #{clone_dir}, fetching updates...")
+
+      case System.cmd("git", ["fetch", "--all"], cd: clone_dir, stderr_to_stdout: true) do
+        {_, 0} -> :ok
+        {err, _} -> Logger.warning("git fetch failed (non-fatal): #{err}")
+      end
+
+      progress_fn.("Reading git log...")
+      run_git_log(clone_dir, options)
+    else
+      progress_fn.("Cloning #{repo_name}...")
+      Logger.info("Cloning #{url} into #{clone_dir}...")
+      File.mkdir_p!(Path.dirname(clone_dir))
+
+      case System.cmd("git", ["clone", "--no-checkout", url, clone_dir],
+             stderr_to_stdout: true,
+             env: [{"GIT_TERMINAL_PROMPT", "0"}]
+           ) do
+        {_, 0} ->
+          progress_fn.("Clone complete, reading git log...")
+          Logger.info("Clone complete")
+          run_git_log(clone_dir, options)
+
+        {error, code} ->
+          {:error, "Git clone failed (#{code}): #{String.trim(error)}"}
+      end
     end
   end
 
+  defp clone_path_for(url) do
+    hash =
+      :crypto.hash(:sha256, url)
+      |> Base.url_encode64(padding: false)
+      |> String.slice(0..11)
+
+    repo_name =
+      url
+      |> String.split("/")
+      |> List.last()
+      |> String.replace(~r/\.git$/, "")
+
+    Path.join([System.tmp_dir!(), "gitlock", "clones", "#{repo_name}_#{hash}"])
+  end
+
   defp add_cache_path(workspace_id, options_hash, cache_path) do
     workspace = Store.get(workspace_id)
     cache = workspace[:git_log_cache] || %{}
@@ -142,6 +215,94 @@ defmodule GitlockCore.Infrastructure.GitRepository do
     end
   end
 
+  @doc """
+  Get the content of a file at a specific revision.
+
+  Uses `git show <revision>:<path>` to retrieve historical file content.
+
+  ## Parameters
+    * `repo_path` - Path to the git repository
+    * `revision` - Git revision (SHA, tag, branch)
+    * `file_path` - Path to the file relative to repo root
+
+  ## Returns
+    * `{:ok, content}` - File content as string
+    * `{:error, reason}` - If the file doesn't exist at that revision
+  """
+  def file_at_revision(repo_path, revision, file_path) do
+    repo_dir = resolve_repo_dir(repo_path)
+
+    case System.cmd("git", ["show", "#{revision}:#{file_path}"],
+           cd: repo_dir,
+           stderr_to_stdout: true
+         ) do
+      {content, 0} -> {:ok, content}
+      {error, _code} -> {:error, String.trim(error)}
+    end
+  end
+
+  @doc """
+  Find the nearest commit SHA to a given date.
+
+  Returns the SHA of the last commit on or before `date`.
+  """
+  def commit_at_date(repo_path, date) do
+    repo_dir = resolve_repo_dir(repo_path)
+    date_str = Date.to_iso8601(date)
+
+    case System.cmd("git", ["log", "--before=#{date_str}T23:59:59", "--format=%H", "-1"],
+           cd: repo_dir,
+           stderr_to_stdout: true
+         ) do
+      {"", 0} -> {:error, :no_commit}
+      {"\n", 0} -> {:error, :no_commit}
+      {sha, 0} -> {:ok, String.trim(sha)}
+      {error, _} -> {:error, String.trim(error)}
+    end
+  end
+
+  @doc """
+  Get the date range of the repository (earliest and latest commit dates).
+  """
+  def date_range(repo_path) do
+    repo_dir = resolve_repo_dir(repo_path)
+
+    with {:ok, earliest} <- earliest_commit_date(repo_dir),
+         {:ok, latest} <- latest_commit_date(repo_dir) do
+      {:ok, earliest, latest}
+    end
+  end
+
+  defp earliest_commit_date(repo_dir) do
+    case System.cmd("git", ["log", "--reverse", "--format=%ad", "--date=short", "-1"],
+           cd: repo_dir,
+           stderr_to_stdout: true
+         ) do
+      {date_str, 0} ->
+        date_str |> String.trim() |> Date.from_iso8601()
+
+      {error, _} ->
+        {:error, String.trim(error)}
+    end
+  end
+
+  defp latest_commit_date(repo_dir) do
+    case System.cmd("git", ["log", "--format=%ad", "--date=short", "-1"],
+           cd: repo_dir,
+           stderr_to_stdout: true
+         ) do
+      {date_str, 0} ->
+        date_str |> String.trim() |> Date.from_iso8601()
+
+      {error, _} ->
+        {:error, String.trim(error)}
+    end
+  end
+
+  defp resolve_repo_dir(repo_path) do
+    if remote_url?(repo_path), do: clone_path_for(repo_path), else: repo_path
+  end
+
   defp build_log_command(options) do
     @default_log_options ++
       Enum.flat_map(options, fn
diff --git a/apps/gitlock_core/lib/gitlock_core/ports/complexity_analyzer_port.ex b/apps/gitlock_core/lib/gitlock_core/ports/complexity_analyzer_port.ex
index c8a575c..e9cb997 100644
--- a/apps/gitlock_core/lib/gitlock_core/ports/complexity_analyzer_port.ex
+++ b/apps/gitlock_core/lib/gitlock_core/ports/complexity_analyzer_port.ex
@@ -32,6 +32,18 @@ defmodule GitlockCore.Ports.ComplexityAnalyzerPort do
               opts :: map()
             ) :: {:ok, %{String.t() => ComplexityMetrics.t()}} | {:error, String.t()}
 
+  @doc """
+  Analyze complexity from a content string (no disk read).
+
+  Used for historical analysis where file content is retrieved from
+  version control at a specific commit.
+
+  ## Returns
+    * `{:ok, %ComplexityMetrics{}}` on success
+  """
+  @callback analyze_content(content :: String.t(), file_path :: String.t()) ::
+              {:ok, ComplexityMetrics.t()}
+
   @doc "List of file extensions this analyzer will process (e.g. [\".ex\", \".exs\"])."
   @callback supported_extensions() :: [String.t()]
 end
diff --git a/apps/gitlock_core/lib/gitlock_core/ports/version_control_port.ex b/apps/gitlock_core/lib/gitlock_core/ports/version_control_port.ex
index e16e805..5b080a6 100644
--- a/apps/gitlock_core/lib/gitlock_core/ports/version_control_port.ex
+++ b/apps/gitlock_core/lib/gitlock_core/ports/version_control_port.ex
@@ -31,4 +31,37 @@ defmodule GitlockCore.Ports.VersionControlPort do
     * `{:error, reason}` on failure  
   """
   @callback get_commit_history(repo_path(), options()) :: success() | error()
+
+  @doc """
+  Retrieve the contents of a file at a specific commit.
+
+  ## Parameters
+
+    * `repo_path` — path to the repository
+    * `commit_id` — the commit SHA
+    * `file_path` — path to the file relative to repo root
+
+  ## Returns
+
+    * `{:ok, content}` on success
+    * `{:error, reason}` if the file doesn't exist at that commit
+  """
+  @callback get_file_at_commit(repo_path(), String.t(), String.t()) ::
+              {:ok, String.t()} | {:error, term()}
+
+  @doc """
+  List files that exist at a specific commit.
+
+  ## Parameters
+
+    * `repo_path` — path to the repository
+    * `commit_id` — the commit SHA
+
+  ## Returns
+
+    * `{:ok, [file_path]}` on success
+    * `{:error, reason}` on failure
+  """
+  @callback list_files_at_commit(repo_path(), String.t()) ::
+              {:ok, [String.t()]} | {:error, term()}
 end
diff --git a/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/elixir_analyzer_test.exs b/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/elixir_analyzer_test.exs
index d2e4088..34ef862 100644
--- a/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/elixir_analyzer_test.exs
+++ b/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/elixir_analyzer_test.exs
@@ -9,46 +9,22 @@ defmodule GitlockCore.Adapters.Complexity.Lang.ElixirAnalyzerTest do
     end
   end
 
-  describe "analyze_file/1" do
-    setup do
-      # Create a temporary directory for test files
-      {:ok, test_dir} = Briefly.create(directory: true)
-
-      {:ok, test_dir: test_dir}
-    end
-
-    test "analyzes simple Elixir code", %{test_dir: test_dir} do
-      # Create a simple Elixir file
-      simple_path = Path.join(test_dir, "simple.ex")
-
-      simple_code = """
+  describe "calculate_complexity/2 - basic constructs" do
+    test "simple module with no branching = 1" do
+      code = """
       defmodule Simple do
-        def hello do
-          "world"
-        end
+        def hello, do: "world"
       end
       """
 
-      File.write!(simple_path, simple_code)
-
-      # Analyze the file
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(simple_path)
-
-      # Verify results
-      assert metrics.file_path == simple_path
-      assert metrics.language == :elixir
-      # 6 lines + trailings \n
-      assert metrics.loc == 6
-      assert metrics.cyclomatic_complexity > 0
+      assert ElixirAnalyzer.calculate_complexity(code, "test.ex") == 1
     end
 
-    test "analyzes code with if statements", %{test_dir: test_dir} do
-      path = Path.join(test_dir, "if_statements.ex")
-
+    test "if statement adds 1" do
       code = """
-      defmodule IfStatements do
-        def test(value) do
-          if value > 0 do
+      defmodule M do
+        def test(x) do
+          if x > 0 do
             :positive
           else
             :negative
@@ -57,334 +33,291 @@ defmodule GitlockCore.Adapters.Complexity.Lang.ElixirAnalyzerTest do
       end
       """
 
-      File.write!(path, code)
-
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
-
-      # 1 (base) + 1 (if) = at least 2
-      assert metrics.cyclomatic_complexity >= 2
+      # 1 base + 1 if = 2
+      assert ElixirAnalyzer.calculate_complexity(code, "test.ex") == 2
     end
 
-    test "analyzes code with case expressions", %{test_dir: test_dir} do
-      path = Path.join(test_dir, "case.ex")
-
+    test "case counts each clause" do
       code = """
-      defmodule CaseStatements do
-        def test(value) do
-          case value do
-            x when x > 0 -> :positive
-            x when x < 0 -> :negative
-            0 -> :zero
+      defmodule M do
+        def test(x) do
+          case x do
+            :a -> 1
+            :b -> 2
+            _ -> 3
           end
         end
       end
       """
 
-      File.write!(path, code)
-
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
-
-      # 1 (base) + 3 (case clauses) = at least 4
-      assert metrics.cyclomatic_complexity >= 4
+      # 1 base + 3 clauses = 4
+      assert ElixirAnalyzer.calculate_complexity(code, "test.ex") == 4
     end
 
-    test "analyzes code with cond expressions", %{test_dir: test_dir} do
-      path = Path.join(test_dir, "cond.ex")
-
+    test "cond counts each condition" do
       code = """
-      defmodule CondStatements do
-        def test(value) do
+      defmodule M do
+        def test(x) do
           cond do
-            value > 10 -> :high
-            value > 0 -> :positive
-            value < 0 -> :negative
-            true -> :zero
+            x > 10 -> :high
+            x > 0 -> :positive
+            true -> :other
           end
         end
       end
       """
 
-      File.write!(path, code)
-
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
-
-      # 1 (base) + 4 (cond clauses) = at least 5
-      assert metrics.cyclomatic_complexity >= 5
+      # 1 base + 3 cond clauses = 4
+      assert ElixirAnalyzer.calculate_complexity(code, "test.ex") == 4
     end
 
-    test "analyzes code with boolean operators", %{test_dir: test_dir} do
-      path = Path.join(test_dir, "boolean_ops.ex")
-
+    test "boolean operators add complexity" do
       code = """
-      defmodule BooleanOps do
-        def test(a, b, c) do
-          if a && (b || c) do
-            :true
-          else
-            :false
+      defmodule M do
+        def test(a, b) do
+          if a && b do
+            :both
           end
         end
       end
       """
 
-      File.write!(path, code)
-
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
-
-      # 1 (base) + 1 (if) + 2 (boolean ops) = at least 4
-      assert metrics.cyclomatic_complexity >= 4
+      # 1 base + 1 if + 1 && = 3
+      assert ElixirAnalyzer.calculate_complexity(code, "test.ex") == 3
     end
+  end
 
-    test "analyzes code with nested function definitions", %{test_dir: test_dir} do
-      path = Path.join(test_dir, "functions.ex")
-
+  describe "calculate_complexity/2 - with statement" do
+    test "with clauses add complexity" do
       code = """
-      defmodule Functions do
-        def public_function(value) do
-          if value > 0 do
-            helper(value)
-          else
-            :negative
-          end
-        end
-        
-        defp helper(value) do
-          cond do
-            value > 10 -> :high
-            true -> :normal
+      defmodule M do
+        def test(a, b) do
+          with {:ok, x} <- fetch(a),
+               {:ok, y} <- fetch(b) do
+            {:ok, x + y}
           end
         end
       end
       """
 
-      File.write!(path, code)
-
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
-
-      # Should detect complexity from both functions and their contents
-      assert metrics.cyclomatic_complexity >= 4
+      complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
+      # 1 base + 2 with clauses = 3
+      assert complexity >= 3
     end
 
-    test "handles syntax errors gracefully", %{test_dir: test_dir} do
-      path = Path.join(test_dir, "syntax_error.ex")
-
+    test "with/else counts else clauses" do
       code = """
-      defmodule InvalidSyntax do
-        def missing_end do
-          if true do
-            :true
-          # Missing end
+      defmodule M do
+        def test(input) do
+          with {:ok, parsed} <- parse(input),
+               {:ok, valid} <- validate(parsed) do
+            {:ok, valid}
+          else
+            {:error, :parse} -> {:error, "bad parse"}
+            {:error, :validate} -> {:error, "invalid"}
+          end
+        end
       end
       """
 
-      File.write!(path, code)
-
-      # Should return metrics with negative complexity for errors
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
-      assert metrics.cyclomatic_complexity == -1
-    end
-
-    test "handles empty files", %{test_dir: test_dir} do
-      path = Path.join(test_dir, "empty.ex")
-      File.write!(path, "")
-
-      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
-
-      assert metrics.file_path == path
-      # Empty file has 1 line
-      assert metrics.loc == 1
-      # Base complexity is 1
-      assert metrics.cyclomatic_complexity == 1
-    end
-
-    test "handles file not found errors" do
-      result = ElixirAnalyzer.analyze_file("/path/to/nonexistent/file.ex")
-      assert {:error, {:io, "/path/to/nonexistent/file.ex", :enoent}} = result
+      complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
+      # 1 base + 2 with + 2 else = 5
+      assert complexity >= 5
     end
   end
 
-  describe "analyze_directory/2" do
-    setup do
-      # Create a temporary directory using Briefly
-      {:ok, tmp_dir} = Briefly.create(directory: true)
-
-      # Create subdirectory
-      subdir = Path.join(tmp_dir, "subdir")
-      File.mkdir_p!(subdir)
-
-      # Briefly automatically cleans up when tests finish
-
-      {:ok, test_dir: tmp_dir, subdir: subdir}
-    end
-
-    test "analyzes all Elixir files in a directory", %{test_dir: test_dir, subdir: subdir} do
-      # Create several Elixir files
-      File.write!(Path.join(test_dir, "module1.ex"), """
-      defmodule Module1 do
-        def function1(x) do
-          if x > 0, do: :positive, else: :negative
-        end
-      end
-      """)
-
-      File.write!(Path.join(test_dir, "module2.ex"), """
-      defmodule Module2 do
-        def function2(x) do
-          case x do
-            n when n > 0 -> :positive
-            n when n < 0 -> :negative
-            _ -> :zero
+  describe "calculate_complexity/2 - try/rescue/catch" do
+    test "rescue clauses add complexity" do
+      code = """
+      defmodule M do
+        def test(x) do
+          try do
+            risky(x)
+          rescue
+            ArgumentError -> :arg_error
+            RuntimeError -> :runtime_error
           end
         end
       end
-      """)
+      """
 
-      File.write!(Path.join(subdir, "module3.ex"), """
-      defmodule Subdir.Module3 do
-        def function3(x) do
-          cond do
-            x > 10 -> :high
-            x > 0 -> :positive
-            x < 0 -> :negative
-            true -> :zero
+      complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
+      # 1 base + 2 rescue clauses = 3
+      assert complexity >= 3
+    end
+
+    test "catch clauses add complexity" do
+      code = """
+      defmodule M do
+        def test(x) do
+          try do
+            risky(x)
+          catch
+            :exit, _ -> :exited
+            :throw, val -> val
           end
         end
       end
-      """)
+      """
 
-      # Create a non-Elixir file (should be ignored)
-      File.write!(Path.join(test_dir, "readme.txt"), "Not an Elixir file")
-
-      # Analyze the directory
-      results = ElixirAnalyzer.analyze_directory(test_dir)
-
-      # Should have found all 3 Elixir files
-      assert map_size(results) == 3
-      assert Map.has_key?(results, "module1.ex")
-      assert Map.has_key?(results, "module2.ex")
-      assert Map.has_key?(results, "subdir/module3.ex")
-      assert not Map.has_key?(results, "readme.txt")
-
-      # Verify each file was analyzed correctly
-      assert results["module1.ex"].language == :elixir
-      assert results["module2.ex"].language == :elixir
-      assert results["subdir/module3.ex"].language == :elixir
-
-      # Check complexity values increase with more complex code structures
-      # if statement
-      assert results["module1.ex"].cyclomatic_complexity >= 2
-      # case with clauses
-      assert results["module2.ex"].cyclomatic_complexity >= 3
-      # cond with clauses
-      assert results["subdir/module3.ex"].cyclomatic_complexity >= 4
+      complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
+      assert complexity >= 3
     end
+  end
 
-    test "handles non-existent directory" do
-      non_existent = "/not/a/real/directory/#{:rand.uniform(10000)}"
-      result = ElixirAnalyzer.analyze_directory(non_existent)
-      assert {:error, _message} = result
-    end
+  describe "calculate_complexity/2 - receive" do
+    test "receive clauses add complexity" do
+      code = """
+      defmodule M do
+        def loop do
+          receive do
+            {:msg, data} -> handle(data)
+            :stop -> :ok
+          after
+            5000 -> :timeout
+          end
+        end
+      end
+      """
 
-    test "handles empty directory", %{test_dir: test_dir} do
-      # Directory exists but has no files
-      results = ElixirAnalyzer.analyze_directory(test_dir)
-      assert is_map(results)
-      assert map_size(results) == 0
+      complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
+      # 1 base + 2 receive clauses + 1 after = 4
+      assert complexity >= 4
     end
   end
 
-  describe "calculate_complexity/2" do
-    test "calculates correct complexity for simple code" do
+  describe "calculate_complexity/2 - multi-clause functions" do
+    test "function with guard adds 1" do
       code = """
-      defmodule Simple do
-        def hello do
-          "world"
-        end
+      defmodule M do
+        def test(x) when x > 0, do: :positive
+        def test(_), do: :other
       end
       """
 
       complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
-      # Base complexity for a simple function
-      assert complexity == 1
+      # 1 base + 1 guard = 2
+      assert complexity >= 2
     end
+  end
 
-    test "calculates correct complexity for if statements" do
+  describe "calculate_complexity/2 - anonymous functions" do
+    test "multi-clause fn adds complexity" do
       code = """
-      defmodule IfTest do
-        def test(x) do
-          if x > 0 do
-            :positive
-          else
-            :negative
+      defmodule M do
+        def test do
+          handler = fn
+            :ok -> :success
+            :error -> :failure
+            _ -> :unknown
           end
+
+          handler.(:ok)
         end
       end
       """
 
       complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
-      # 1 (base) + 1 (if statement) = 2
-      assert complexity == 2
+      # 1 base + 3 fn clauses = 4
+      assert complexity >= 4
     end
 
-    test "calculates correct complexity for case expressions" do
+    test "single-clause fn does not add extra complexity" do
       code = """
-      defmodule CaseTest do
-        def test(x) do
-          case x do
-            n when n > 0 -> :positive
-            n when n < 0 -> :negative
-            _ -> :zero
-          end
+      defmodule M do
+        def test do
+          Enum.map([1, 2, 3], fn x -> x * 2 end)
         end
       end
       """
 
-      complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
-      # Should count each case clause
-      assert complexity >= 4
+      # 1 base, single-clause fn doesn't branch
+      assert ElixirAnalyzer.calculate_complexity(code, "test.ex") == 1
     end
+  end
 
-    test "calculates correct complexity for complex nested code" do
+  describe "calculate_complexity/2 - nested complexity" do
+    test "deeply nested code accumulates correctly" do
       code = """
-      defmodule ComplexTest do
+      defmodule M do
         def test(x, y, z) do
           if x > 0 do
             if y > 0 do
               case z do
-                z when z > 10 -> :high_z
-                z when z > 0 -> :positive_z
-                _ -> :non_positive_z
+                :a -> 1
+                :b -> 2
+                _ -> 3
               end
             else
               cond do
-                x > 10 && z > 0 -> :high_x_with_z
-                x > 5 || z < 0 -> :medium_x
+                x > 10 && z > 0 -> :high
+                x > 5 || z < 0 -> :medium
                 true -> :fallback
               end
             end
           else
-            :negative_x
+            :negative
           end
         end
       end
       """
 
       complexity = ElixirAnalyzer.calculate_complexity(code, "test.ex")
-      # Has multiple nested conditions, should have high complexity
+      # 1 base + 2 ifs + 3 case + 3 cond + 2 boolean = 11
       assert complexity > 7
     end
   end
 
+  describe "calculate_complexity/2 - error handling" do
+    test "syntax errors return -1" do
+      code = """
+      defmodule Bad do
+        def missing_end do
+          if true do
+            :true
+      end
+      """
+
+      assert ElixirAnalyzer.calculate_complexity(code, "test.ex") == -1
+    end
+
+    test "empty string returns 1" do
+      assert ElixirAnalyzer.calculate_complexity("", "test.ex") == 1
+    end
+  end
+
+  describe "analyze_file/1" do
+    setup do
+      {:ok, test_dir} = Briefly.create(directory: true)
+      {:ok, test_dir: test_dir}
+    end
+
+    test "analyzes file and returns metrics", %{test_dir: test_dir} do
+      path = Path.join(test_dir, "simple.ex")
+
+      File.write!(path, """
+      defmodule Simple do
+        def hello, do: "world"
+      end
+      """)
+
+      {:ok, metrics} = ElixirAnalyzer.analyze_file(path)
+
+      assert metrics.file_path == path
+      assert metrics.language == :elixir
+      assert metrics.loc > 0
+      assert metrics.cyclomatic_complexity == 1
+    end
+
+    test "handles file not found" do
+      assert {:error, {:io, _, :enoent}} = ElixirAnalyzer.analyze_file("/nonexistent.ex")
+    end
+  end
+
   describe "behavior compliance" do
     test "implements ComplexityAnalyzerPort behavior" do
       behaviors = ElixirAnalyzer.__info__(:attributes)[:behaviour] || []
       assert GitlockCore.Ports.ComplexityAnalyzerPort in behaviors
-
-      # Test callback functions exist
-      functions = ElixirAnalyzer.__info__(:functions)
-      assert Keyword.has_key?(functions, :analyze_file)
-      assert Keyword.has_key?(functions, :analyze_directory)
-      assert Keyword.has_key?(functions, :supported_extensions)
     end
   end
 end
diff --git a/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/javascript_analyzer_test.exs b/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/javascript_analyzer_test.exs
index 40354a6..fd79764 100644
--- a/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/javascript_analyzer_test.exs
+++ b/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/javascript_analyzer_test.exs
@@ -1,137 +1,142 @@
-defmodule GitlockCore.Adapters.Complexity.Lang.JavascriptAnalyzerTest do
+defmodule GitlockCore.Adapters.Complexity.Lang.JavaScriptAnalyzerTest do
   use ExUnit.Case, async: true
 
   alias GitlockCore.Adapters.Complexity.Lang.JavaScriptAnalyzer
 
   describe "supported_extensions/0" do
-    test "returns JavaScript file extensions" do
-      assert JavaScriptAnalyzer.supported_extensions() == [".js", ".jsx", ".ts", ".tsx"]
+    test "returns JS/TS file extensions" do
+      assert JavaScriptAnalyzer.supported_extensions() == [".js", ".jsx"]
     end
   end
 
-  describe "analyze_file/1" do
-    setup do
-      # Create a temporary directory for test files
-      {:ok, test_dir} = Briefly.create(directory: true)
+  describe "analyze_content/2 - basic constructs" do
+    test "simple function with no branching" do
+      code = """
+      function hello() {
+        return "world";
+      }
+      """
 
-      {:ok, test_dir: test_dir}
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      # 1 base + 1 function decl = 2
+      assert metrics.cyclomatic_complexity >= 1
     end
 
-    test "calculates complexity for JavaScript function declarations", %{test_dir: test_dir} do
-      # Create a JavaScript file with multiple functions
-      js_path = Path.join(test_dir, "functions.js")
-
-      js_content = """
-      function simpleFunction() {
-        return true;
-      }
-
-      function conditionalFunction(value) {
-        if (value > 10) {
-          return 'high';
-        } else if (value > 5) {
-          return 'medium';
-        } else {
-          return 'low';
+    test "if statement adds complexity" do
+      code = """
+      function test(x) {
+        if (x > 0) {
+          return "positive";
         }
       }
+      """
 
-      function loopFunction(items) {
-        for (let i = 0; i < items.length; i++) {
-          if (items[i] > 10) {
-            console.log('high value');
-          }
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      assert metrics.cyclomatic_complexity >= 2
+    end
+
+    test "switch case counts each case" do
+      code = """
+      function test(x) {
+        switch(x) {
+          case 1: return "one";
+          case 2: return "two";
+          case 3: return "three";
         }
       }
       """
 
-      File.write!(js_path, js_content)
-
-      {:ok, metrics} = JavaScriptAnalyzer.analyze_file(js_path)
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      # 1 base + 1 fn + 3 cases = 5
+      assert metrics.cyclomatic_complexity >= 4
+    end
 
-      # Base complexity + 3 functions + 3 if statements + 1 else if + 1 for loop
-      # Total should be at least 9
-      assert metrics.cyclomatic_complexity >= 9
-      assert metrics.language == :javascript
+    test "logical operators add complexity" do
+      code = """
+      function test(a, b) {
+        if (a && b || c) {
+          return true;
+        }
+      }
+      """
 
-      # Fix: Adapt the test to match the actual line count
-      # The analyzer counts 22 lines, likely including blank lines or handling line breaks differently
-      assert metrics.loc == 22
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      # 1 base + 1 fn + 1 if + 1 && + 1 || = 5
+      assert metrics.cyclomatic_complexity >= 4
     end
+  end
 
-    test "handles modern JavaScript features", %{test_dir: test_dir} do
-      js_path = Path.join(test_dir, "modern.js")
-
-      js_content = """
-      // Arrow functions
-      const simple = () => true;
+  describe "analyze_content/2 - comment/string stripping" do
+    test "if inside a single-line comment is NOT counted" do
+      code = """
+      function test() {
+        // if (this should not count)
+        return 1;
+      }
+      """
 
-      // Arrow function with condition
-      const conditional = value => value > 10 ? 'high' : 'low';
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      # 1 base + 1 fn, NO if = 2
+      assert metrics.cyclomatic_complexity <= 3
+    end
 
-      // Class with methods
-      class Calculator {
-        constructor() {
-          this.value = 0;
-        }
-        
-        add(x) {
-          this.value += x;
-          return this;
-        }
-        
-        multiply(x) {
-          if (x === 0) {
-            console.warn('Multiplying by zero');
-          }
-          this.value *= x;
-          return this;
-        }
+    test "if inside a multi-line comment is NOT counted" do
+      code = """
+      function test() {
+        /* if (x > 0) {
+          return "this is a comment";
+        } */
+        return 1;
       }
-
-      // Logical operators
-      const hasPermission = user => {
-        return user && user.isActive && (user.role === 'admin' || user.permissions.includes('edit'));
-      };
       """
 
-      File.write!(js_path, js_content)
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      assert metrics.cyclomatic_complexity <= 3
+    end
 
-      {:ok, metrics} = JavaScriptAnalyzer.analyze_file(js_path)
+    test "if inside a string literal is NOT counted" do
+      code = """
+      function test() {
+        const msg = "if this is counted, it's a bug";
+        const other = 'if single quotes too';
+        return msg;
+      }
+      """
 
-      # Should detect arrow functions, ternary, class methods, and logical operators
-      assert metrics.cyclomatic_complexity >= 7
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      assert metrics.cyclomatic_complexity <= 3
     end
 
-    test "handles empty files", %{test_dir: test_dir} do
-      js_path = Path.join(test_dir, "empty.js")
-      File.write!(js_path, "")
-
-      {:ok, metrics} = JavaScriptAnalyzer.analyze_file(js_path)
+    test "if inside a template literal is NOT counted" do
+      code = """
+      function test() {
+        const msg = `if (x > 0) { this is a template literal }`;
+        return msg;
+      }
+      """
 
-      # Base complexity
-      assert metrics.cyclomatic_complexity >= 1
-      # Empty file has 1 line
-      assert metrics.loc == 1
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      assert metrics.cyclomatic_complexity <= 3
     end
+  end
 
-    test "handles syntax errors gracefully", %{test_dir: test_dir} do
-      js_path = Path.join(test_dir, "syntax_error.js")
-
-      js_content = """
-      function brokenFunction( {
-        // Missing closing parenthesis
-        if (true) {
-          return "something";
-        }
-      }
+  describe "analyze_content/2 - arrow functions" do
+    test "arrow functions are counted" do
+      code = """
+      const add = (a, b) => a + b;
+      const multiply = (a, b) => a * b;
       """
 
-      File.write!(js_path, js_content)
+      {:ok, metrics} = JavaScriptAnalyzer.analyze_content(code, "test.js")
+      # 1 base + 2 arrows = 3
+      assert metrics.cyclomatic_complexity >= 3
+    end
+  end
 
-      # Should still return metrics despite syntax errors
-      {:ok, metrics} = JavaScriptAnalyzer.analyze_file(js_path)
-      assert metrics.cyclomatic_complexity >= 1
+  describe "behavior compliance" do
+    test "implements ComplexityAnalyzerPort behavior" do
+      behaviors = JavaScriptAnalyzer.__info__(:attributes)[:behaviour] || []
+      assert GitlockCore.Ports.ComplexityAnalyzerPort in behaviors
     end
   end
 end
diff --git a/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/typescript_analyzer_test.exs b/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/typescript_analyzer_test.exs
new file mode 100644
index 0000000..3b8a6c2
--- /dev/null
+++ b/apps/gitlock_core/test/gitlock_core/adapters/complexity/lang/typescript_analyzer_test.exs
@@ -0,0 +1,355 @@
+defmodule GitlockCore.Adapters.Complexity.Lang.TypeScriptAnalyzerTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockCore.Adapters.Complexity.Lang.TypeScriptAnalyzer
+
+  describe "supported_extensions/0" do
+    test "returns TypeScript file extensions" do
+      assert TypeScriptAnalyzer.supported_extensions() == [".ts", ".tsx"]
+    end
+  end
+
+  describe "analyze_content/2 - JS constructs still work" do
+    test "simple function with no branching" do
+      code = """
+      function hello(): string {
+        return "world";
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 function
+      assert metrics.cyclomatic_complexity >= 2
+      assert metrics.language == :typescript
+    end
+
+    test "if/else counts correctly" do
+      code = """
+      function test(x: number): string {
+        if (x > 0) {
+          return "positive";
+        } else {
+          return "non-positive";
+        }
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 fn + 1 if = 3
+      assert metrics.cyclomatic_complexity >= 3
+    end
+
+    test "switch case counts each case" do
+      code = """
+      function describe(status: Status): string {
+        switch (status) {
+          case "active": return "running";
+          case "paused": return "waiting";
+          case "done": return "finished";
+          default: return "unknown";
+        }
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 fn + 3 cases (default is not `case`) = 5
+      assert metrics.cyclomatic_complexity >= 4
+    end
+
+    test "logical operators" do
+      code = """
+      function check(a: boolean, b: boolean, c: boolean): boolean {
+        return a && b || c;
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 fn + 1 && + 1 || = 4
+      assert metrics.cyclomatic_complexity >= 4
+    end
+
+    test "arrow functions" do
+      code = """
+      const add = (a: number, b: number): number => a + b;
+      const mul = (a: number, b: number): number => a * b;
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 2 arrows = 3
+      assert metrics.cyclomatic_complexity >= 3
+    end
+  end
+
+  describe "analyze_content/2 - type constructs stripped (no false positives)" do
+    test "conditional types do NOT count as ternary" do
+      code = """
+      type IsString<T> = T extends string ? true : false;
+      type Result<T> = T extends Error ? never : T;
+
+      function simple(): void {
+        console.log("no branches here");
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # Should NOT count the two `?` in conditional types
+      # 1 base + 1 fn = 2
+      assert metrics.cyclomatic_complexity <= 3
+    end
+
+    test "interface declarations do NOT add complexity" do
+      code = """
+      interface User {
+        name: string;
+        age: number;
+        isActive: boolean;
+      }
+
+      function greet(user: User): string {
+        return "hello";
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 fn = 2
+      assert metrics.cyclomatic_complexity <= 3
+    end
+
+    test "type aliases do NOT add complexity" do
+      code = """
+      type Status = "active" | "inactive" | "pending";
+      type Handler = (event: Event) => void;
+
+      function process(): void {
+        return;
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      assert metrics.cyclomatic_complexity <= 3
+    end
+
+    test "generic type parameters do NOT cause false positives" do
+      code = """
+      function identity<T extends Comparable>(value: T): T {
+        return value;
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 fn = 2
+      assert metrics.cyclomatic_complexity <= 3
+    end
+
+    test "enum declarations do NOT add complexity" do
+      code = """
+      enum Direction {
+        Up = "UP",
+        Down = "DOWN",
+        Left = "LEFT",
+        Right = "RIGHT",
+      }
+
+      function move(): void {
+        return;
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      assert metrics.cyclomatic_complexity <= 3
+    end
+  end
+
+  describe "analyze_content/2 - TypeScript-specific patterns" do
+    test "optional chaining counts as branch" do
+      code = """
+      function getName(user: User | null): string {
+        const name = user?.name;
+        const city = user?.address?.city;
+        return name ?? "unknown";
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 fn + 2 optional chain + 1 nullish = 5
+      assert metrics.cyclomatic_complexity >= 4
+    end
+
+    test "type guard functions count as decision point" do
+      code = """
+      function isString(value: unknown): value is string {
+        return typeof value === "string";
+      }
+
+      function isUser(obj: any): obj is User {
+        return obj && typeof obj.name === "string";
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # Should count the type guard signatures
+      assert metrics.cyclomatic_complexity >= 3
+    end
+
+    test "nullish coalescing counts" do
+      code = """
+      function defaults(config: Partial<Config>): Config {
+        const timeout = config.timeout ?? 5000;
+        const retries = config.retries ?? 3;
+        return { timeout, retries };
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + 1 fn + 2 ?? = 4
+      assert metrics.cyclomatic_complexity >= 4
+    end
+  end
+
+  describe "analyze_content/2 - comments and strings" do
+    test "if inside comment NOT counted" do
+      code = """
+      function test(): void {
+        // if (this should not count)
+        /* if (neither should this) */
+        return;
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      assert metrics.cyclomatic_complexity <= 3
+    end
+
+    test "if inside string literal NOT counted" do
+      code = """
+      function test(): string {
+        return "if this is counted it is a bug";
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      assert metrics.cyclomatic_complexity <= 3
+    end
+  end
+
+  describe "analyze_content/2 - realistic TypeScript code" do
+    test "React component with hooks" do
+      code = """
+      interface Props {
+        userId: string;
+        onError?: (err: Error) => void;
+      }
+
+      type Status = "loading" | "error" | "success";
+
+      function UserProfile({ userId, onError }: Props): JSX.Element {
+        const [status, setStatus] = useState<Status>("loading");
+
+        useEffect(() => {
+          fetchUser(userId)
+            .then(data => {
+              if (data) {
+                setStatus("success");
+              } else {
+                setStatus("error");
+              }
+            })
+            .catch(err => {
+              onError?.(err);
+              setStatus("error");
+            });
+        }, [userId]);
+
+        if (status === "loading") {
+          return <Spinner />;
+        }
+
+        if (status === "error") {
+          return <ErrorView />;
+        }
+
+        return <Profile />;
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.tsx")
+      # Has real runtime complexity: ifs, arrow fns, optional chain, catch
+      assert metrics.cyclomatic_complexity >= 6
+      assert metrics.language == :typescript
+    end
+
+    test "service class with error handling" do
+      code = """
+      class ApiService {
+        async fetchData<T>(url: string): Promise<T> {
+          try {
+            const response = await fetch(url);
+            if (!response.ok) {
+              throw new Error("HTTP error");
+            }
+            return await response.json();
+          } catch (error) {
+            if (error instanceof TypeError) {
+              throw new NetworkError("Network failed");
+            }
+            throw error;
+          }
+        }
+      }
+      """
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_content(code, "test.ts")
+      # 1 base + arrows/fns + 2 ifs + 1 catch = high
+      assert metrics.cyclomatic_complexity >= 4
+    end
+  end
+
+  describe "analyze_file/1" do
+    setup do
+      {:ok, test_dir} = Briefly.create(directory: true)
+      {:ok, test_dir: test_dir}
+    end
+
+    test "analyzes .ts file", %{test_dir: dir} do
+      path = Path.join(dir, "app.ts")
+
+      File.write!(path, """
+      function greet(name: string): string {
+        if (name) {
+          return `Hello, ${name}`;
+        }
+        return "Hello, stranger";
+      }
+      """)
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_file(path)
+      assert metrics.file_path == path
+      assert metrics.language == :typescript
+      assert metrics.cyclomatic_complexity >= 2
+    end
+
+    test "analyzes .tsx file", %{test_dir: dir} do
+      path = Path.join(dir, "component.tsx")
+
+      File.write!(path, """
+      function Button({ label }: { label: string }) {
+        return <button>{label}</button>;
+      }
+      """)
+
+      {:ok, metrics} = TypeScriptAnalyzer.analyze_file(path)
+      assert metrics.language == :typescript
+    end
+
+    test "handles file not found" do
+      assert {:error, {:io, _, :enoent}} = TypeScriptAnalyzer.analyze_file("/nonexistent.ts")
+    end
+  end
+
+  describe "behavior compliance" do
+    test "implements ComplexityAnalyzerPort behavior" do
+      behaviors = TypeScriptAnalyzer.__info__(:attributes)[:behaviour] || []
+      assert GitlockCore.Ports.ComplexityAnalyzerPort in behaviors
+    end
+  end
+end
diff --git a/apps/gitlock_core/test/gitlock_core/domain/values/hotspot_test.exs b/apps/gitlock_core/test/gitlock_core/domain/values/hotspot_test.exs
index 5f1b2c8..2de5aa4 100644
--- a/apps/gitlock_core/test/gitlock_core/domain/values/hotspot_test.exs
+++ b/apps/gitlock_core/test/gitlock_core/domain/values/hotspot_test.exs
@@ -70,7 +70,9 @@ defmodule GitlockCore.Domain.Values.HotspotTest do
         revisions: 10,
         complexity: 15,
         risk_factor: :high,
-        risk_score: 7.8
+        risk_score: 7.8,
+        normalized_score: 85.3,
+        percentile: 95.0
       }
 
       result = Hotspot.to_string(hotspot)
@@ -79,7 +81,8 @@ defmodule GitlockCore.Domain.Values.HotspotTest do
       assert String.contains?(result, "file.ex")
       assert String.contains?(result, "10 revisions")
       assert String.contains?(result, "complexity: 15")
-      assert String.contains?(result, "7.8")
+      assert String.contains?(result, "85.3/100")
+      assert String.contains?(result, "top 5.0%")
       assert String.contains?(result, "HIGH RISK")
     end
   end
diff --git a/apps/gitlock_phx/assets/build.mjs b/apps/gitlock_phx/assets/build.mjs
new file mode 100644
index 0000000..3a6d9ed
--- /dev/null
+++ b/apps/gitlock_phx/assets/build.mjs
@@ -0,0 +1,44 @@
+import * as esbuild from "esbuild";
+import sveltePlugin from "esbuild-svelte";
+
+const args = process.argv.slice(2);
+const watch = args.includes("--watch");
+const deploy = args.includes("--deploy");
+
+/** @type {import('esbuild').BuildOptions} */
+const buildOptions = {
+  entryPoints: ["js/app.js"],
+  bundle: true,
+  target: "es2022",
+  outdir: "../priv/static/assets/js",
+  external: ["/fonts/*", "/images/*"],
+  mainFields: ["svelte", "browser", "module", "main"],
+  conditions: ["svelte", "browser"],
+  logLevel: "info",
+  nodePaths: ["../../../deps"],
+  plugins: [
+    sveltePlugin({
+      compilerOptions: {
+        css: "injected",
+      },
+    }),
+  ],
+  loader: {
+    ".svg": "text",
+  },
+};
+
+if (deploy) {
+  buildOptions.minify = true;
+  buildOptions.sourcemap = false;
+} else {
+  buildOptions.sourcemap = "inline";
+}
+
+if (watch) {
+  const ctx = await esbuild.context(buildOptions);
+  await ctx.watch();
+  console.log("[esbuild+svelte] watching for changes...");
+} else {
+  await esbuild.build(buildOptions);
+}
diff --git a/apps/gitlock_phx/assets/css/analyze.css b/apps/gitlock_phx/assets/css/analyze.css
new file mode 100644
index 0000000..3a4e672
--- /dev/null
+++ b/apps/gitlock_phx/assets/css/analyze.css
@@ -0,0 +1,302 @@
+/* ── Analyze Page ─────────────────────── */
+.analyze-page {
+  min-height: 100vh;
+  background: #0e0e1a;
+  padding: 48px 20px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+}
+
+.analyze-container {
+  max-width: 760px;
+  margin: 0 auto;
+}
+
+.analyze-header {
+  text-align: center;
+  margin-bottom: 36px;
+}
+
+.analyze-header h1 {
+  color: #e0e0ee;
+  font-size: 26px;
+  font-weight: 700;
+  margin: 0 0 6px 0;
+}
+
+.analyze-subtitle {
+  color: #6e6e88;
+  font-size: 14px;
+  margin: 0;
+}
+
+/* ── Form ────────────────────────────── */
+.analyze-form {
+  background: #16162a;
+  border: 1px solid #252540;
+  border-radius: 12px;
+  padding: 28px;
+  margin-bottom: 20px;
+}
+
+.form-group {
+  margin-bottom: 20px;
+}
+
+.form-group label {
+  display: block;
+  color: #8e8ea8;
+  font-size: 11px;
+  font-weight: 600;
+  margin-bottom: 8px;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+
+.analyze-input {
+  width: 100%;
+  background: #1e1e2e;
+  border: 1px solid #2e2e48;
+  color: #e0e0ee;
+  padding: 12px 16px;
+  border-radius: 8px;
+  font-size: 14px;
+  font-family: inherit;
+  outline: none;
+  transition: border-color 0.12s;
+  box-sizing: border-box;
+}
+
+.analyze-input::placeholder { color: #4e4e68; }
+.analyze-input:focus { border-color: #6366f1; }
+
+/* ── Template Cards ──────────────────── */
+.template-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+  gap: 10px;
+}
+
+.template-card {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  padding: 14px 16px;
+  background: #1e1e2e;
+  border: 1.5px solid #2e2e48;
+  border-radius: 10px;
+  cursor: pointer;
+  text-align: left;
+  color: #c0c0d0;
+  transition: border-color 0.12s, background 0.12s;
+  font-family: inherit;
+}
+
+.template-card:hover {
+  background: #242440;
+  border-color: #3e3e58;
+}
+
+.template-card.selected {
+  border-color: #6366f1;
+  background: #1e1e38;
+}
+
+.template-name {
+  font-size: 14px;
+  font-weight: 600;
+  color: #e0e0ee;
+}
+
+.template-desc {
+  font-size: 12px;
+  color: #6e6e88;
+}
+
+.template-nodes {
+  font-size: 11px;
+  color: #4e4e68;
+  margin-top: 2px;
+}
+
+/* ── Submit ───────────────────────────── */
+.analyze-submit {
+  width: 100%;
+  padding: 14px;
+  background: #6366f1;
+  color: #fff;
+  border: none;
+  border-radius: 8px;
+  font-size: 14px;
+  font-weight: 600;
+  font-family: inherit;
+  cursor: pointer;
+  transition: background 0.12s;
+}
+
+.analyze-submit:hover:not(:disabled) { background: #5558e6; }
+.analyze-submit:disabled { opacity: 0.3; cursor: not-allowed; }
+.analyze-submit.running { background: #f59e0b; }
+
+/* ── Progress ────────────────────────── */
+.analyze-progress {
+  background: #16162a;
+  border: 1px solid #252540;
+  border-radius: 12px;
+  padding: 24px;
+  margin-bottom: 20px;
+}
+
+.analyze-progress h2 {
+  color: #e0e0ee;
+  font-size: 16px;
+  font-weight: 600;
+  margin: 0 0 14px 0;
+}
+
+.progress-nodes {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.progress-node {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 14px;
+  border-radius: 8px;
+  background: #1e1e2e;
+  font-size: 13px;
+  color: #b0b0c0;
+  border-left: 3px solid transparent;
+}
+
+.progress-node.running { border-left-color: #f59e0b; color: #fbbf24; }
+.progress-node.done { border-left-color: #10b981; color: #34d399; }
+.progress-node.error { border-left-color: #ef4444; color: #f87171; }
+
+.progress-indicator {
+  display: flex;
+  align-items: center;
+  width: 16px;
+  height: 16px;
+  flex-shrink: 0;
+}
+
+.status-spin { animation: spin 0.8s linear infinite; }
+@keyframes spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
+
+/* ── Results ─────────────────────────── */
+.analyze-results { margin-bottom: 20px; }
+
+.analyze-results h2 {
+  color: #e0e0ee;
+  font-size: 18px;
+  font-weight: 600;
+  margin: 0 0 14px 0;
+}
+
+.result-card {
+  background: #16162a;
+  border: 1px solid #252540;
+  border-radius: 12px;
+  padding: 20px;
+  margin-bottom: 12px;
+}
+
+.result-card.error { border-color: rgba(239, 68, 68, 0.2); }
+
+.result-card-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 14px;
+}
+
+.result-card h3 {
+  color: #e0e0ee;
+  font-size: 15px;
+  font-weight: 600;
+  margin: 0;
+}
+
+.result-count {
+  color: #6e6e88;
+  font-size: 11px;
+  background: #1e1e2e;
+  padding: 3px 10px;
+  border-radius: 6px;
+}
+
+.result-table-wrap { overflow-x: auto; }
+
+.result-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+}
+
+.result-table th {
+  text-align: left;
+  color: #6e6e88;
+  font-weight: 600;
+  padding: 8px 10px;
+  border-bottom: 1px solid #252540;
+  white-space: nowrap;
+  position: sticky;
+  top: 0;
+  background: #16162a;
+  text-transform: capitalize;
+}
+
+.result-table td {
+  color: #b0b0c0;
+  padding: 7px 10px;
+  border-bottom: 1px solid #1e1e30;
+  max-width: 220px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.result-table tbody tr:hover { background: #1e1e2e; }
+.result-table.kv th { width: 150px; color: #a78bfa; }
+
+.result-raw {
+  color: #b0b0c0;
+  font-size: 12px;
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+  font-family: ui-monospace, 'SF Mono', monospace;
+  background: #1e1e2e;
+  padding: 12px;
+  border-radius: 8px;
+}
+
+.result-error {
+  color: #f87171;
+  font-size: 12px;
+  margin: 0;
+  white-space: pre-wrap;
+  font-family: ui-monospace, 'SF Mono', monospace;
+}
+
+.result-truncated {
+  color: #5e5e78;
+  font-size: 11px;
+  text-align: center;
+  padding: 8px 0;
+  margin: 0;
+}
+
+.analyze-error {
+  background: rgba(239, 68, 68, 0.08);
+  border: 1px solid rgba(239, 68, 68, 0.15);
+  border-radius: 10px;
+  padding: 16px;
+  color: #f87171;
+  font-size: 13px;
+}
+
+.analyze-error p { margin: 0; }
diff --git a/apps/gitlock_phx/assets/css/app.css b/apps/gitlock_phx/assets/css/app.css
index bbb60f1..384e006 100644
--- a/apps/gitlock_phx/assets/css/app.css
+++ b/apps/gitlock_phx/assets/css/app.css
@@ -1,9 +1,13 @@
 /* See the Tailwind configuration guide for advanced usage
    https://tailwindcss.com/docs/configuration */
 @import "./landing.css";
+@import "./workflow.css";
+@import "./analyze.css";
+@import "./runs.css";
 @import "tailwindcss" source(none);
 @source "../css";
 @source "../js";
+@source "../svelte";
 @source "../../lib/gitlock_phx_web";
 
 /* A Tailwind plugin that makes "hero-#{ICON}" classes available.
diff --git a/apps/gitlock_phx/assets/css/runs.css b/apps/gitlock_phx/assets/css/runs.css
new file mode 100644
index 0000000..343bc98
--- /dev/null
+++ b/apps/gitlock_phx/assets/css/runs.css
@@ -0,0 +1,224 @@
+/* ── Runs List Page ───────────────────── */
+.runs-page {
+  min-height: 100vh;
+  background: #0e0e1a;
+  padding: 48px 20px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+}
+
+.runs-container {
+  max-width: 760px;
+  margin: 0 auto;
+}
+
+.runs-header {
+  margin-bottom: 28px;
+}
+
+.runs-header h1 {
+  color: #e0e0ee;
+  font-size: 26px;
+  font-weight: 700;
+  margin: 0 0 6px 0;
+}
+
+.runs-subtitle {
+  color: #6e6e88;
+  font-size: 14px;
+  margin: 0;
+}
+
+/* ── Run Row ─────────────────────────── */
+.runs-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.run-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 14px 18px;
+  background: #16162a;
+  border: 1px solid #252540;
+  border-radius: 10px;
+  text-decoration: none;
+  transition: border-color 0.12s, background 0.12s;
+}
+
+.run-row:hover {
+  background: #1a1a32;
+  border-color: #3e3e58;
+}
+
+.run-row-main {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  min-width: 0;
+  flex: 1;
+}
+
+.run-status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+  background: #6e6e88;
+}
+
+.run-status-dot.completed { background: #10b981; }
+.run-status-dot.running { background: #f59e0b; animation: pulse-dot 1.5s ease-in-out infinite; }
+.run-status-dot.failed { background: #ef4444; }
+
+@keyframes pulse-dot {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.4; }
+}
+
+.run-info {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
+}
+
+.run-pipeline-name {
+  color: #e0e0ee;
+  font-size: 14px;
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.run-repo {
+  color: #5e5e78;
+  font-size: 12px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  font-family: ui-monospace, 'SF Mono', monospace;
+}
+
+.run-row-meta {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-shrink: 0;
+}
+
+.run-status-label {
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  padding: 3px 8px;
+  border-radius: 5px;
+  color: #6e6e88;
+  background: #1e1e2e;
+}
+
+.run-status-label.completed { color: #34d399; background: rgba(16, 185, 129, 0.1); }
+.run-status-label.running { color: #fbbf24; background: rgba(245, 158, 11, 0.1); }
+.run-status-label.failed { color: #f87171; background: rgba(239, 68, 68, 0.1); }
+
+.run-duration {
+  color: #5e5e78;
+  font-size: 12px;
+  font-family: ui-monospace, 'SF Mono', monospace;
+}
+
+.run-time {
+  color: #4e4e68;
+  font-size: 12px;
+  white-space: nowrap;
+}
+
+/* ── Empty State ─────────────────────── */
+.runs-empty {
+  background: #16162a;
+  border: 1px solid #252540;
+  border-radius: 12px;
+  padding: 40px;
+  text-align: center;
+}
+
+.runs-empty p {
+  color: #6e6e88;
+  font-size: 14px;
+  margin: 0 0 8px 0;
+}
+
+.runs-empty p:last-child { margin-bottom: 0; }
+
+.runs-empty a {
+  color: #818cf8;
+  text-decoration: none;
+}
+
+.runs-empty a:hover { text-decoration: underline; }
+
+/* ── Run Detail Page ─────────────────── */
+.run-detail-page {
+  min-height: 100vh;
+  background: #0e0e1a;
+  padding: 48px 20px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+}
+
+.run-detail-container {
+  max-width: 900px;
+  margin: 0 auto;
+}
+
+.run-detail-header {
+  margin-bottom: 24px;
+}
+
+.run-back {
+  color: #6e6e88;
+  font-size: 12px;
+  text-decoration: none;
+  display: inline-block;
+  margin-bottom: 8px;
+  transition: color 0.12s;
+}
+
+.run-back:hover { color: #a0a0c0; }
+
+.run-detail-header h1 {
+  color: #e0e0ee;
+  font-size: 22px;
+  font-weight: 700;
+  margin: 0 0 10px 0;
+}
+
+.run-detail-meta {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.run-meta-item {
+  color: #5e5e78;
+  font-size: 12px;
+  font-family: ui-monospace, 'SF Mono', monospace;
+}
+
+.run-error-banner {
+  background: rgba(239, 68, 68, 0.08);
+  border: 1px solid rgba(239, 68, 68, 0.15);
+  border-radius: 10px;
+  padding: 14px 18px;
+  color: #f87171;
+  font-size: 13px;
+  margin-bottom: 20px;
+}
+
+.run-error-banner strong {
+  font-weight: 600;
+}
diff --git a/apps/gitlock_phx/assets/css/workflow.css b/apps/gitlock_phx/assets/css/workflow.css
new file mode 100644
index 0000000..315b8f1
--- /dev/null
+++ b/apps/gitlock_phx/assets/css/workflow.css
@@ -0,0 +1,468 @@
+/* ── Workflow Page Layout ─────────────── */
+.workflow-page {
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+  background: #0e0e1a;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+}
+
+.workflow-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 20px;
+  height: 52px;
+  background: #16162a;
+  border-bottom: 1px solid #252540;
+  flex-shrink: 0;
+}
+
+.workflow-header h1 {
+  color: #e0e0ee;
+  font-size: 15px;
+  font-weight: 600;
+  margin: 0;
+}
+
+.workflow-actions {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+/* ── Badges ──────────────────────────── */
+.validation-badge {
+  padding: 4px 12px;
+  border-radius: 6px;
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.validation-badge.valid {
+  background: rgba(16, 185, 129, 0.12);
+  color: #34d399;
+}
+
+.validation-badge.invalid {
+  background: rgba(239, 68, 68, 0.12);
+  color: #f87171;
+}
+
+/* ── Buttons ─────────────────────────── */
+.btn {
+  padding: 6px 14px;
+  border-radius: 6px;
+  font-size: 12px;
+  font-weight: 500;
+  cursor: pointer;
+  border: none;
+  transition: background 0.12s, opacity 0.12s;
+  font-family: inherit;
+}
+
+.btn-secondary {
+  background: #252540;
+  color: #b0b0c0;
+  border: 1px solid #2e2e48;
+}
+
+.btn-secondary:hover {
+  background: #2e2e48;
+  color: #d0d0e0;
+}
+
+/* ── Template Select ─────────────────── */
+.template-dropdown {
+  display: contents;
+}
+
+.template-select {
+  background: #1e1e2e;
+  border: 1px solid #2e2e48;
+  color: #b0b0c0;
+  padding: 6px 12px;
+  border-radius: 6px;
+  font-size: 12px;
+  font-family: inherit;
+  outline: none;
+  cursor: pointer;
+  transition: border-color 0.12s;
+  -webkit-appearance: none;
+  appearance: none;
+  background-image: url("data:image/svg+xml,%3Csvg width='10' height='6' viewBox='0 0 10 6' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M1 1L5 5L9 1' stroke='%236e6e88' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
+  background-repeat: no-repeat;
+  background-position: right 10px center;
+  padding-right: 28px;
+}
+
+.template-select:hover { border-color: #3e3e58; }
+.template-select:focus { border-color: #6366f1; }
+
+/* ── Execute Button ──────────────────── */
+.btn-execute {
+  background: #6366f1;
+  color: #fff;
+  font-weight: 600;
+}
+
+.btn-execute:hover:not(:disabled) {
+  background: #5558e6;
+}
+
+.btn-execute:disabled {
+  opacity: 0.35;
+  cursor: not-allowed;
+}
+
+.btn-execute.running {
+  background: #f59e0b;
+}
+
+.btn-execute.done {
+  background: #10b981;
+}
+
+/* ── Title Group ──────────────────────── */
+.workflow-title-group {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-width: 0;
+}
+
+.workflow-header h1[contenteditable] {
+  outline: none;
+  border-radius: 4px;
+  padding: 2px 6px;
+  margin: -2px -6px;
+  transition: background 0.12s;
+  cursor: text;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 300px;
+}
+
+.workflow-header h1[contenteditable]:hover {
+  background: rgba(255, 255, 255, 0.04);
+}
+
+.workflow-header h1[contenteditable]:focus {
+  background: rgba(255, 255, 255, 0.06);
+  box-shadow: 0 0 0 1px #6366f1;
+}
+
+.dirty-badge {
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 10px;
+  font-weight: 600;
+  background: rgba(245, 158, 11, 0.12);
+  color: #fbbf24;
+  flex-shrink: 0;
+}
+
+.saved-badge {
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 10px;
+  font-weight: 600;
+  background: rgba(16, 185, 129, 0.12);
+  color: #34d399;
+  flex-shrink: 0;
+}
+
+/* ── Save Dialog ─────────────────────── */
+.save-dialog-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.6);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 100;
+  backdrop-filter: blur(4px);
+}
+
+.save-dialog {
+  background: #1e1e2e;
+  border: 1px solid #2e2e48;
+  border-radius: 12px;
+  padding: 24px;
+  min-width: 360px;
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+}
+
+.save-dialog h3 {
+  color: #e0e0ee;
+  font-size: 16px;
+  font-weight: 600;
+  margin: 0 0 16px;
+}
+
+.save-field {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 20px;
+}
+
+.save-field label {
+  color: #8e8ea8;
+  font-size: 12px;
+  font-weight: 500;
+}
+
+.save-input {
+  background: #16162a;
+  border: 1px solid #2e2e48;
+  color: #e0e0ee;
+  padding: 10px 14px;
+  border-radius: 8px;
+  font-size: 14px;
+  font-family: inherit;
+  outline: none;
+  transition: border-color 0.12s;
+}
+
+.save-input:focus {
+  border-color: #6366f1;
+}
+
+.save-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+}
+
+/* ── Pipelines Page ──────────────────── */
+.pipelines-page {
+  min-height: 100vh;
+  background: #0e0e1a;
+  padding: 40px 20px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+}
+
+.pipelines-container {
+  max-width: 960px;
+  margin: 0 auto;
+}
+
+.pipelines-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 32px;
+}
+
+.pipelines-header h1 {
+  color: #e0e0ee;
+  font-size: 24px;
+  font-weight: 700;
+  margin: 0;
+}
+
+.pipelines-section {
+  margin-bottom: 40px;
+}
+
+.pipelines-section h2 {
+  color: #8e8ea8;
+  font-size: 13px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  margin: 0 0 16px;
+}
+
+.pipelines-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  gap: 12px;
+}
+
+.pipeline-card {
+  background: #16162a;
+  border: 1px solid #252540;
+  border-radius: 10px;
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  transition: border-color 0.12s;
+}
+
+.pipeline-card:hover {
+  border-color: #3e3e58;
+}
+
+.pipeline-card.template {
+  border-left: 3px solid #6366f1;
+}
+
+.pipeline-card-body h3 {
+  margin: 0 0 6px;
+  font-size: 15px;
+  font-weight: 600;
+}
+
+.pipeline-card-body h3 a {
+  color: #e0e0ee;
+  text-decoration: none;
+}
+
+.pipeline-card-body h3 a:hover {
+  color: #6366f1;
+}
+
+.pipeline-desc {
+  color: #6e6e88;
+  font-size: 12px;
+  margin: 0 0 8px;
+  line-height: 1.4;
+}
+
+.pipeline-meta {
+  display: flex;
+  gap: 12px;
+  font-size: 11px;
+  color: #5e5e78;
+}
+
+.template-badge {
+  background: rgba(99, 102, 241, 0.12);
+  color: #818cf8;
+  padding: 1px 8px;
+  border-radius: 4px;
+  font-weight: 600;
+}
+
+.pipeline-card-actions {
+  display: flex;
+  gap: 8px;
+}
+
+.btn-sm {
+  padding: 4px 10px;
+  font-size: 11px;
+}
+
+.btn-danger {
+  background: rgba(239, 68, 68, 0.1);
+  color: #f87171;
+  border: 1px solid rgba(239, 68, 68, 0.15);
+}
+
+.btn-danger:hover {
+  background: rgba(239, 68, 68, 0.18);
+}
+
+.pipelines-empty {
+  text-align: center;
+  padding: 60px 20px;
+  color: #5e5e78;
+  font-size: 14px;
+}
+
+.pipelines-empty a {
+  color: #818cf8;
+  text-decoration: underline;
+}
+
+/* ── Inline Flash Messages ────────────── */
+.workflow-flash {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 16px;
+  font-size: 13px;
+  font-weight: 500;
+  flex-shrink: 0;
+  animation: flash-slide-in 0.2s ease-out;
+}
+
+.workflow-flash-error {
+  background: rgba(239, 68, 68, 0.12);
+  color: #f87171;
+  border-bottom: 1px solid rgba(239, 68, 68, 0.15);
+}
+
+.workflow-flash-info {
+  background: rgba(16, 185, 129, 0.12);
+  color: #34d399;
+  border-bottom: 1px solid rgba(16, 185, 129, 0.15);
+}
+
+.workflow-flash-warning {
+  background: rgba(245, 158, 11, 0.12);
+  color: #fbbf24;
+  border-bottom: 1px solid rgba(245, 158, 11, 0.15);
+}
+
+.flash-dismiss {
+  background: none;
+  border: none;
+  color: inherit;
+  opacity: 0.5;
+  cursor: pointer;
+  font-size: 14px;
+  padding: 0 4px;
+  font-family: inherit;
+}
+
+.flash-dismiss:hover {
+  opacity: 1;
+}
+
+@keyframes flash-slide-in {
+  from { opacity: 0; transform: translateY(-4px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+/* ── Canvas Mount Point ──────────────── */
+.workflow-canvas {
+  flex: 1;
+  overflow: hidden;
+  min-height: 0;
+}
+
+/* ── SvelteFlow Overrides ────────────── */
+.workflow-canvas :global(.svelte-flow__minimap) {
+  background: #16162a;
+  border: 1px solid #252540;
+  border-radius: 8px;
+}
+
+.workflow-canvas :global(.svelte-flow__controls) {
+  border: 1px solid #252540;
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.workflow-canvas :global(.svelte-flow__controls button) {
+  background: #1e1e2e;
+  color: #b0b0c0;
+  border-bottom: 1px solid #252540;
+  width: 28px;
+  height: 28px;
+}
+
+.workflow-canvas :global(.svelte-flow__controls button:hover) {
+  background: #252540;
+  color: #e0e0ee;
+}
+
+.workflow-canvas :global(.svelte-flow__edge-path) {
+  stroke: #4e4e68;
+  stroke-width: 1.5;
+}
+
+.workflow-canvas :global(.svelte-flow__edge.animated path) {
+  stroke: #6366f1;
+}
+
+.workflow-canvas :global(.svelte-flow__connection-path) {
+  stroke: #6366f1;
+  stroke-width: 2;
+}
diff --git a/apps/gitlock_phx/assets/js/app.js b/apps/gitlock_phx/assets/js/app.js
index a32a703..223b989 100644
--- a/apps/gitlock_phx/assets/js/app.js
+++ b/apps/gitlock_phx/assets/js/app.js
@@ -25,7 +25,24 @@ import { LiveSocket } from "phoenix_live_view";
 import topbar from "../vendor/topbar";
 import "./theme.js";
 
-let Hooks = {};
+import WorkflowHook from "./hooks/workflow_hook";
+
+let Hooks = {
+  WorkflowCanvas: WorkflowHook,
+  ContentEditable: {
+    mounted() {
+      this.el.addEventListener("blur", () => {
+        this.pushEvent("rename", { value: this.el.innerText });
+      });
+      this.el.addEventListener("keydown", (e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          this.el.blur();
+        }
+      });
+    },
+  },
+};
 
 const csrfToken = document
   .querySelector("meta[name='csrf-token']")
diff --git a/apps/gitlock_phx/assets/js/hooks/workflow_hook.js b/apps/gitlock_phx/assets/js/hooks/workflow_hook.js
new file mode 100644
index 0000000..d1b7308
--- /dev/null
+++ b/apps/gitlock_phx/assets/js/hooks/workflow_hook.js
@@ -0,0 +1,137 @@
+import { mount, unmount } from "svelte";
+import WorkflowCanvas from "../../svelte/workflow/WorkflowCanvas.svelte";
+import {
+  flowNodes,
+  flowEdges,
+  flowCatalog,
+  flowCallbacks,
+} from "../../svelte/workflow/stores.js";
+
+/**
+ * Transforms Elixir Pipeline JSON into SvelteFlow format.
+ */
+function pipelineToFlow(pipeline) {
+  const nodes = Object.values(pipeline.nodes || {}).map((node) => ({
+    id: node.id,
+    type: node.category || "analyze",
+    position: { x: node.position[0] || 0, y: node.position[1] || 0 },
+    data: {
+      label: node.label,
+      category: node.category,
+      type: node.type,
+      input_ports: node.input_ports || [],
+      output_ports: node.output_ports || [],
+      config: node.config || {},
+      config_schema: node.config_schema || [],
+    },
+  }));
+
+  const edges = Object.values(pipeline.edges || {}).map((edge) => ({
+    id: edge.id,
+    source: edge.source_node_id,
+    target: edge.target_node_id,
+    sourceHandle: edge.source_port_id,
+    targetHandle: edge.target_port_id,
+    type: "smoothstep",
+    animated: true,
+  }));
+
+  return { nodes, edges };
+}
+
+const WorkflowHook = {
+  mounted() {
+    // Register callbacks: Svelte → LiveView
+    flowCallbacks.set({
+      onConnect: (connection) => {
+        this.pushEvent("connect", {
+          source_node_id: connection.source,
+          source_port_id: connection.sourceHandle,
+          target_node_id: connection.target,
+          target_port_id: connection.targetHandle,
+        });
+      },
+
+      onNodeDragStop: (nodeId, position) => {
+        this.pushEvent("node_moved", {
+          node_id: nodeId,
+          position: { x: position.x, y: position.y },
+        });
+      },
+
+      onAddNode: (typeId, position) => {
+        this.pushEvent("add_node", {
+          type_id: typeId,
+          position: { x: position.x, y: position.y },
+        });
+      },
+
+      onDeleteElements: (payload) => {
+        this.pushEvent("delete_elements", payload);
+      },
+
+      onUpdateNodeConfig: (nodeId, config) => {
+        this.pushEvent("update_node_config", {
+          node_id: nodeId,
+          config: config,
+        });
+      },
+    });
+
+    // Listen for state pushes from LiveView
+    this.handleEvent("pipeline_state", (payload) => {
+      const { nodes, edges } = pipelineToFlow(payload.pipeline);
+      flowNodes.set(nodes);
+      flowEdges.set(edges);
+    });
+
+    this.handleEvent("catalog", (payload) => {
+      flowCatalog.set(payload.catalog);
+    });
+
+    // Mount Svelte component
+    this.component = mount(WorkflowCanvas, {
+      target: this.el,
+    });
+
+    // Listen for node execution progress
+    this.handleEvent("node_progress", ({ node_id, status, result, error, status_text }) => {
+      flowNodes.update((nodes) =>
+        nodes.map((n) =>
+          n.id === node_id
+            ? {
+                ...n,
+                data: {
+                  ...n.data,
+                  executionStatus: status,
+                  statusText: status_text || n.data.statusText || null,
+                  result: result || n.data.result || null,
+                  error: error || null,
+                },
+              }
+            : n
+        )
+      );
+    });
+
+    this.handleEvent("execution_started", () => {
+      flowNodes.update((nodes) =>
+        nodes.map((n) => ({
+          ...n,
+          data: { ...n.data, executionStatus: null, statusText: null, result: null, error: null },
+        }))
+      );
+    });
+
+    // Request initial state
+    this.pushEvent("request_state", {});
+  },
+
+  destroyed() {
+    if (this.component) {
+      unmount(this.component);
+    }
+  },
+};
+
+export default WorkflowHook;
diff --git a/apps/gitlock_phx/assets/package-lock.json b/apps/gitlock_phx/assets/package-lock.json
new file mode 100644
index 0000000..85b25bd
--- /dev/null
+++ b/apps/gitlock_phx/assets/package-lock.json
@@ -0,0 +1,881 @@
+{
+  "name": "gitlock_phx_assets",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "gitlock_phx_assets",
+      "dependencies": {
+        "@xyflow/svelte": "^1.0.0",
+        "phoenix": "file:../deps/phoenix",
+        "phoenix_html": "file:../deps/phoenix_html",
+        "phoenix_live_view": "file:../deps/phoenix_live_view",
+        "svelte": "^5.0.0"
+      },
+      "devDependencies": {
+        "esbuild": "^0.23.0",
+        "esbuild-svelte": "^0.9.4"
+      }
+    },
+    "../deps/phoenix": {},
+    "../deps/phoenix_html": {},
+    "../deps/phoenix_live_view": {},
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.23.1.tgz",
+      "integrity": "sha512-6VhYk1diRqrhBAqpJEdjASR/+WVRtfjpqKuNw11cLiaWpAT/Uu+nokB+UJnevzy/P9C/ty6AOe0dwueMrGh/iQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.23.1.tgz",
+      "integrity": "sha512-uz6/tEy2IFm9RYOyvKl88zdzZfwEfKZmnX9Cj1BHjeSGNuGLuMD1kR8y5bteYmwqKm1tj8m4cb/aKEorr6fHWQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.23.1.tgz",
+      "integrity": "sha512-xw50ipykXcLstLeWH7WRdQuysJqejuAGPd30vd1i5zSyKK3WE+ijzHmLKxdiCMtH1pHz78rOg0BKSYOSB/2Khw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.23.1.tgz",
+      "integrity": "sha512-nlN9B69St9BwUoB+jkyU090bru8L0NA3yFvAd7k8dNsVH8bi9a8cUAUSEcEEgTp2z3dbEDGJGfP6VUnkQnlReg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.23.1.tgz",
+      "integrity": "sha512-YsS2e3Wtgnw7Wq53XXBLcV6JhRsEq8hkfg91ESVadIrzr9wO6jJDMZnCQbHm1Guc5t/CdDiFSSfWP58FNuvT3Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.23.1.tgz",
+      "integrity": "sha512-aClqdgTDVPSEGgoCS8QDG37Gu8yc9lTHNAQlsztQ6ENetKEO//b8y31MMu2ZaPbn4kVsIABzVLXYLhCGekGDqw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.23.1.tgz",
+      "integrity": "sha512-h1k6yS8/pN/NHlMl5+v4XPfikhJulk4G+tKGFIOwURBSFzE8bixw1ebjluLOjfwtLqY0kewfjLSrO6tN2MgIhA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.23.1.tgz",
+      "integrity": "sha512-lK1eJeyk1ZX8UklqFd/3A60UuZ/6UVfGT2LuGo3Wp4/z7eRTRYY+0xOu2kpClP+vMTi9wKOfXi2vjUpO1Ro76g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.23.1.tgz",
+      "integrity": "sha512-CXXkzgn+dXAPs3WBwE+Kvnrf4WECwBdfjfeYHpMeVxWE0EceB6vhWGShs6wi0IYEqMSIzdOF1XjQ/Mkm5d7ZdQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.23.1.tgz",
+      "integrity": "sha512-/93bf2yxencYDnItMYV/v116zff6UyTjo4EtEQjUBeGiVpMmffDNUyD9UN2zV+V3LRV3/on4xdZ26NKzn6754g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.23.1.tgz",
+      "integrity": "sha512-VTN4EuOHwXEkXzX5nTvVY4s7E/Krz7COC8xkftbbKRYAl96vPiUssGkeMELQMOnLOJ8k3BY1+ZY52tttZnHcXQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.23.1.tgz",
+      "integrity": "sha512-Vx09LzEoBa5zDnieH8LSMRToj7ir/Jeq0Gu6qJ/1GcBq9GkfoEAoXvLiW1U9J1qE/Y/Oyaq33w5p2ZWrNNHNEw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.23.1.tgz",
+      "integrity": "sha512-nrFzzMQ7W4WRLNUOU5dlWAqa6yVeI0P78WKGUo7lg2HShq/yx+UYkeNSE0SSfSure0SqgnsxPvmAUu/vu0E+3Q==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.23.1.tgz",
+      "integrity": "sha512-dKN8fgVqd0vUIjxuJI6P/9SSSe/mB9rvA98CSH2sJnlZ/OCZWO1DJvxj8jvKTfYUdGfcq2dDxoKaC6bHuTlgcw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.23.1.tgz",
+      "integrity": "sha512-5AV4Pzp80fhHL83JM6LoA6pTQVWgB1HovMBsLQ9OZWLDqVY8MVobBXNSmAJi//Csh6tcY7e7Lny2Hg1tElMjIA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.23.1.tgz",
+      "integrity": "sha512-9ygs73tuFCe6f6m/Tb+9LtYxWR4c9yg7zjt2cYkjDbDpV/xVn+68cQxMXCjUpYwEkze2RcU/rMnfIXNRFmSoDw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.23.1.tgz",
+      "integrity": "sha512-EV6+ovTsEXCPAp58g2dD68LxoP/wK5pRvgy0J/HxPGB009omFPv3Yet0HiaqvrIrgPTBuC6wCH1LTOY91EO5hQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.23.1.tgz",
+      "integrity": "sha512-aevEkCNu7KlPRpYLjwmdcuNz6bDFiE7Z8XC4CPqExjTvrHugh28QzUXVOZtiYghciKUacNktqxdpymplil1beA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.23.1.tgz",
+      "integrity": "sha512-3x37szhLexNA4bXhLrCC/LImN/YtWis6WXr1VESlfVtVeoFJBRINPJ3f0a/6LV8zpikqoUg4hyXw0sFBt5Cr+Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.23.1.tgz",
+      "integrity": "sha512-aY2gMmKmPhxfU+0EdnN+XNtGbjfQgwZj43k8G3fyrDM/UdZww6xrWxmDkuz2eCZchqVeABjV5BpildOrUbBTqA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.23.1.tgz",
+      "integrity": "sha512-RBRT2gqEl0IKQABT4XTj78tpk9v7ehp+mazn2HbUeZl1YMdaGAQqhapjGTCe7uw7y0frDi4gS0uHzhvpFuI1sA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.23.1.tgz",
+      "integrity": "sha512-4O+gPR5rEBe2FpKOVyiJ7wNDPA8nGzDuJ6gN4okSA1gEOYZ67N8JPk58tkWtdtPeLz7lBnY6I5L3jdsr3S+A6A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.23.1.tgz",
+      "integrity": "sha512-BcaL0Vn6QwCwre3Y717nVHZbAa4UBEigzFm6VdsVdT/MbZ38xoj1X9HPkZhbmaBGUD1W8vxAfffbDe8bA6AKnQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.23.1.tgz",
+      "integrity": "sha512-BHpFFeslkWrXWyUPnbKm+xYYVYruCinGcftSBaa8zoF9hZO4BcSCFUvHVTtzpIY6YzUnYtuEhZ+C9iEXjxnasg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@svelte-put/shortcut": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@svelte-put/shortcut/-/shortcut-4.1.0.tgz",
+      "integrity": "sha512-wImNEIkbxAIWFqlfuhcbC+jRPDeRa/uJGIXHMEVVD+jqL9xCwWNnkGQJ6Qb2XVszuRLHlb8SGZDL3Io/h3vs8w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "svelte": "^5.1.0"
+      }
+    },
+    "node_modules/@sveltejs/acorn-typescript": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@sveltejs/acorn-typescript/-/acorn-typescript-1.0.9.tgz",
+      "integrity": "sha512-lVJX6qEgs/4DOcRTpo56tmKzVPtoWAaVbL4hfO7t7NVwl9AAXzQR6cihesW1BmNMPl+bK6dreu2sOKBP2Q9CIA==",
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^8.9.0"
+      }
+    },
+    "node_modules/@types/d3-color": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz",
+      "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-drag": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz",
+      "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-interpolate": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz",
+      "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-color": "*"
+      }
+    },
+    "node_modules/@types/d3-selection": {
+      "version": "3.0.11",
+      "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz",
+      "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-transition": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz",
+      "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-zoom": {
+      "version": "3.0.8",
+      "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz",
+      "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-interpolate": "*",
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "license": "MIT"
+    },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "license": "MIT"
+    },
+    "node_modules/@xyflow/svelte": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@xyflow/svelte/-/svelte-1.5.1.tgz",
+      "integrity": "sha512-PsurMZxEaTrAwt+PzQtzEkwZwJ9dSc92kusz1rNJTogU1ATxIwheznO2R+RCf2GNuyRuExeDn26WwwBTqkCIhg==",
+      "license": "MIT",
+      "dependencies": {
+        "@svelte-put/shortcut": "^4.1.0",
+        "@xyflow/system": "0.0.75"
+      },
+      "peerDependencies": {
+        "svelte": "^5.25.0"
+      }
+    },
+    "node_modules/@xyflow/system": {
+      "version": "0.0.75",
+      "resolved": "https://registry.npmjs.org/@xyflow/system/-/system-0.0.75.tgz",
+      "integrity": "sha512-iXs+AGFLi8w/VlAoc/iSxk+CxfT6o64Uw/k0CKASOPqjqz6E0rb5jFZgJtXGZCpfQI6OQpu5EnumP5fGxQheaQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-drag": "^3.0.7",
+        "@types/d3-interpolate": "^3.0.4",
+        "@types/d3-selection": "^3.0.10",
+        "@types/d3-transition": "^3.0.8",
+        "@types/d3-zoom": "^3.0.8",
+        "d3-drag": "^3.0.0",
+        "d3-interpolate": "^3.0.1",
+        "d3-selection": "^3.0.0",
+        "d3-zoom": "^3.0.0"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz",
+      "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/axobject-query": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz",
+      "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/d3-color": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
+      "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-dispatch": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz",
+      "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-drag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz",
+      "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-selection": "3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-ease": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz",
+      "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-interpolate": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
+      "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-color": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-selection": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
+      "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
+      "license": "ISC",
+      "peer": true,
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-timer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz",
+      "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-transition": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz",
+      "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-color": "1 - 3",
+        "d3-dispatch": "1 - 3",
+        "d3-ease": "1 - 3",
+        "d3-interpolate": "1 - 3",
+        "d3-timer": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "peerDependencies": {
+        "d3-selection": "2 - 3"
+      }
+    },
+    "node_modules/d3-zoom": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz",
+      "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-drag": "2 - 3",
+        "d3-interpolate": "1 - 3",
+        "d3-selection": "2 - 3",
+        "d3-transition": "2 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/devalue": {
+      "version": "5.6.3",
+      "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.6.3.tgz",
+      "integrity": "sha512-nc7XjUU/2Lb+SvEFVGcWLiKkzfw8+qHI7zn8WYXKkLMgfGSHbgCEaR6bJpev8Cm6Rmrb19Gfd/tZvGqx9is3wg==",
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.23.1.tgz",
+      "integrity": "sha512-VVNz/9Sa0bs5SELtn3f7qhJCDPCF5oMEl5cO9/SSinpE9hbPVvxbd572HH5AKiP7WD8INO53GgfDDhRjkylHEg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.23.1",
+        "@esbuild/android-arm": "0.23.1",
+        "@esbuild/android-arm64": "0.23.1",
+        "@esbuild/android-x64": "0.23.1",
+        "@esbuild/darwin-arm64": "0.23.1",
+        "@esbuild/darwin-x64": "0.23.1",
+        "@esbuild/freebsd-arm64": "0.23.1",
+        "@esbuild/freebsd-x64": "0.23.1",
+        "@esbuild/linux-arm": "0.23.1",
+        "@esbuild/linux-arm64": "0.23.1",
+        "@esbuild/linux-ia32": "0.23.1",
+        "@esbuild/linux-loong64": "0.23.1",
+        "@esbuild/linux-mips64el": "0.23.1",
+        "@esbuild/linux-ppc64": "0.23.1",
+        "@esbuild/linux-riscv64": "0.23.1",
+        "@esbuild/linux-s390x": "0.23.1",
+        "@esbuild/linux-x64": "0.23.1",
+        "@esbuild/netbsd-x64": "0.23.1",
+        "@esbuild/openbsd-arm64": "0.23.1",
+        "@esbuild/openbsd-x64": "0.23.1",
+        "@esbuild/sunos-x64": "0.23.1",
+        "@esbuild/win32-arm64": "0.23.1",
+        "@esbuild/win32-ia32": "0.23.1",
+        "@esbuild/win32-x64": "0.23.1"
+      }
+    },
+    "node_modules/esbuild-svelte": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/esbuild-svelte/-/esbuild-svelte-0.9.4.tgz",
+      "integrity": "sha512-v/a0GjkKN06nal2QLluxjk2GXsei3fdtjIuHRa6pVnri5rQBZ6pj4a2WwjLfRojgRsLwDHl4xSeZ1BeUHsqQrw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.19"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "esbuild": ">=0.17.0",
+        "svelte": ">=4.2.1 <6"
+      }
+    },
+    "node_modules/esm-env": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
+      "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==",
+      "license": "MIT"
+    },
+    "node_modules/esrap": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.3.tgz",
+      "integrity": "sha512-8fOS+GIGCQZl/ZIlhl59htOlms6U8NvX6ZYgYHpRU/b6tVSh3uHkOHZikl3D4cMbYM0JlpBe+p/BkZEi8J9XIQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.4.15"
+      }
+    },
+    "node_modules/is-reference": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz",
+      "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.6"
+      }
+    },
+    "node_modules/locate-character": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-character/-/locate-character-3.0.0.tgz",
+      "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==",
+      "license": "MIT"
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/phoenix": {
+      "resolved": "../deps/phoenix",
+      "link": true
+    },
+    "node_modules/phoenix_html": {
+      "resolved": "../deps/phoenix_html",
+      "link": true
+    },
+    "node_modules/phoenix_live_view": {
+      "resolved": "../deps/phoenix_live_view",
+      "link": true
+    },
+    "node_modules/svelte": {
+      "version": "5.53.0",
+      "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.53.0.tgz",
+      "integrity": "sha512-7dhHkSamGS2vtoBmIW2hRab+gl5Z60alEHZB4910ePqqJNxAWnDAxsofVmlZ2tREmWyHNE+A1nCKwICAquoD2A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.4",
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@sveltejs/acorn-typescript": "^1.0.5",
+        "@types/estree": "^1.0.5",
+        "@types/trusted-types": "^2.0.7",
+        "acorn": "^8.12.1",
+        "aria-query": "^5.3.1",
+        "axobject-query": "^4.1.0",
+        "clsx": "^2.1.1",
+        "devalue": "^5.6.3",
+        "esm-env": "^1.2.1",
+        "esrap": "^2.2.2",
+        "is-reference": "^3.0.3",
+        "locate-character": "^3.0.0",
+        "magic-string": "^0.30.11",
+        "zimmerframe": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/zimmerframe": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.4.tgz",
+      "integrity": "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==",
+      "license": "MIT"
+    }
+  }
+}
diff --git a/apps/gitlock_phx/assets/package.json b/apps/gitlock_phx/assets/package.json
new file mode 100644
index 0000000..6360807
--- /dev/null
+++ b/apps/gitlock_phx/assets/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "gitlock_phx_assets",
+  "private": true,
+  "dependencies": {
+    "phoenix": "file:../deps/phoenix",
+    "phoenix_html": "file:../deps/phoenix_html",
+    "phoenix_live_view": "file:../deps/phoenix_live_view",
+    "@xyflow/svelte": "^1.0.0",
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.23.0",
+    "esbuild-svelte": "^0.9.4"
+  }
+}
diff --git a/apps/gitlock_phx/assets/svelte/analysis/.gitkeep b/apps/gitlock_phx/assets/svelte/analysis/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/apps/gitlock_phx/assets/svelte/components/.gitkeep b/apps/gitlock_phx/assets/svelte/components/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/apps/gitlock_phx/assets/svelte/dashboard/.gitkeep b/apps/gitlock_phx/assets/svelte/dashboard/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/apps/gitlock_phx/assets/svelte/shared/utils.js b/apps/gitlock_phx/assets/svelte/shared/utils.js
new file mode 100644
index 0000000..d79be6c
--- /dev/null
+++ b/apps/gitlock_phx/assets/svelte/shared/utils.js
@@ -0,0 +1,35 @@
+/**
+ * Shared utilities for Svelte components.
+ * Formatting helpers, constants, etc.
+ */
+
+/**
+ * Format a risk score (0-1) into a human-readable label.
+ */
+export function riskLevel(score) {
+  if (score > 0.8) return 'critical';
+  if (score > 0.6) return 'high';
+  if (score > 0.3) return 'medium';
+  return 'low';
+}
+
+/**
+ * Map risk level to daisyUI color class.
+ */
+export function riskColor(level) {
+  const colors = {
+    critical: 'text-error',
+    high: 'text-warning',
+    medium: 'text-info',
+    low: 'text-success',
+  };
+  return colors[level] || 'text-base-content/50';
+}
+
+/**
+ * Truncate a file path for display, keeping the tail.
+ */
+export function truncatePath(path, maxLen = 40) {
+  if (!path || path.length <= maxLen) return path;
+  return '…' + path.slice(-(maxLen - 1));
+}
diff --git a/apps/gitlock_phx/assets/svelte/workflow/WorkflowCanvas.svelte b/apps/gitlock_phx/assets/svelte/workflow/WorkflowCanvas.svelte
new file mode 100644
index 0000000..2c3cf3f
--- /dev/null
+++ b/apps/gitlock_phx/assets/svelte/workflow/WorkflowCanvas.svelte
@@ -0,0 +1,123 @@
+<script>
+  import { SvelteFlow, Background, Controls, MiniMap, Panel } from '@xyflow/svelte';
+  import '@xyflow/svelte/dist/style.css';
+  import AnalysisNode from './nodes/AnalysisNode.svelte';
+  import NodeConfigPanel from './panels/NodeConfigPanel.svelte';
+  import { flowNodes, flowEdges, flowCatalog, flowCallbacks, configPanelNode } from './stores.js';
+
+  const nodeTypes = {
+    source: AnalysisNode,
+    analyze: AnalysisNode,
+    output: AnalysisNode,
+    logic: AnalysisNode,
+  };
+
+  let nodes = $state([]);
+  let edges = $state([]);
+  let catalog = $state([]);
+  let callbacks = $state({
+    onConnect: () => {},
+    onNodeDragStop: () => {},
+    onAddNode: () => {},
+    onDeleteElements: () => {},
+    onUpdateNodeConfig: () => {},
+  });
+  let panelNode = $state(null);
+
+  flowNodes.subscribe(v => { nodes = v; });
+  flowEdges.subscribe(v => { edges = v; });
+  flowCatalog.subscribe(v => { catalog = v; });
+  flowCallbacks.subscribe(v => { callbacks = v; });
+  configPanelNode.subscribe(v => { panelNode = v; });
+
+  function handleConnect(connection) {
+    callbacks.onConnect({
+      source: connection.source,
+      sourceHandle: connection.sourceHandle,
+      target: connection.target,
+      targetHandle: connection.targetHandle,
+    });
+  }
+
+  function handleNodeDragStop({ targetNode }) {
+    if (targetNode) callbacks.onNodeDragStop(targetNode.id, targetNode.position);
+  }
+
+  function handleDelete({ nodes: dn, edges: de }) {
+    const nids = dn.map(n => n.id);
+    const eids = de.map(e => e.id);
+    if (nids.length > 0 || eids.length > 0) callbacks.onDeleteElements({ nodes: nids, edges: eids });
+  }
+
+  function handleNodeClick({ node }) {
+    configPanelNode.set({ ...node.data, id: node.id });
+  }
+
+  function handlePaneClick() { configPanelNode.set(null); }
+
+  function handleDragOver(e) { e.preventDefault(); e.dataTransfer.dropEffect = 'move'; }
+
+  function handleDrop(e) {
+    e.preventDefault();
+    const typeId = e.dataTransfer.getData('application/gitlock-node-type');
+    if (!typeId) return;
+    const b = e.currentTarget.getBoundingClientRect();
+    callbacks.onAddNode(typeId, { x: e.clientX - b.left, y: e.clientY - b.top });
+  }
+
+  const categoryAccents = {
+    source: '#4ecdc4',
+    analyze: '#ff6b35',
+    output: '#a78bfa',
+    logic: '#fbbf24',
+  };
+</script>
+
+<div class="flex w-full h-full">
+  <!-- Sidebar palette -->
+  <aside class="w-[200px] bg-[#16162a] border-r border-[#252540] px-3 py-4 overflow-y-auto shrink-0 flex flex-col gap-1">
+    <div class="text-[11px] font-bold uppercase tracking-widest text-[#5e5e78] px-1 pb-2.5">Nodes</div>
+    {#each catalog as category}
+      <div>
+        <div class="text-[10px] font-semibold uppercase tracking-wide text-[#4e4e68] px-1 pt-2.5 pb-1">{category.name}</div>
+        {#each category.types as nt}
+          <div
+            class="flex items-center gap-2.5 px-2.5 py-2 bg-[#1e1e2e] border border-[#2a2a40] rounded-lg cursor-grab transition-all duration-100 hover:bg-[#252540] hover:border-[#3a3a58] hover:-translate-y-px active:cursor-grabbing active:translate-y-0"
+            draggable="true"
+            ondragstart={(e) => { e.dataTransfer.setData('application/gitlock-node-type', nt.type_id); e.dataTransfer.effectAllowed = 'move'; }}
+          >
+            <div class="w-[3px] h-5 rounded-sm shrink-0" style="background: {categoryAccents[nt.category] || '#888'}"></div>
+            <span class="text-xs font-medium text-[#c8c8d8]">{nt.label}</span>
+          </div>
+        {/each}
+      </div>
+    {/each}
+  </aside>
+
+  <!-- Canvas -->
+  <div class="flex-1 h-full min-w-0" role="application" ondragover={handleDragOver} ondrop={handleDrop}>
+    <SvelteFlow
+      bind:nodes
+      bind:edges
+      {nodeTypes}
+      onconnect={handleConnect}
+      onnodedragstop={handleNodeDragStop}
+      ondelete={handleDelete}
+      onnodeclick={handleNodeClick}
+      onpaneclick={handlePaneClick}
+      fitView
+      colorMode="dark"
+      defaultEdgeOptions={{ type: 'smoothstep', animated: true }}
+    >
+      <Background gap={20} />
+      <Controls position="bottom-left" />
+      <MiniMap />
+      <Panel position="bottom-right">
+        <div class="text-[11px] text-[#5e5e78] bg-[#16162a]/90 px-3 py-1 rounded-md backdrop-blur-sm">{nodes.length} nodes &middot; {edges.length} edges</div>
+      </Panel>
+    </SvelteFlow>
+  </div>
+
+  <!-- Config / Results panel -->
+  <NodeConfigPanel />
+</div>
diff --git a/apps/gitlock_phx/assets/svelte/workflow/nodes/AnalysisNode.svelte b/apps/gitlock_phx/assets/svelte/workflow/nodes/AnalysisNode.svelte
new file mode 100644
index 0000000..9e68c42
--- /dev/null
+++ b/apps/gitlock_phx/assets/svelte/workflow/nodes/AnalysisNode.svelte
@@ -0,0 +1,121 @@
+<script>
+  import { Handle, Position } from '@xyflow/svelte';
+
+  let { data, selected } = $props();
+
+  const categoryColors = {
+    source: { accent: '#4ecdc4', bg: 'rgba(78, 205, 196, 0.08)' },
+    analyze: { accent: '#ff6b35', bg: 'rgba(255, 107, 53, 0.08)' },
+    output: { accent: '#a78bfa', bg: 'rgba(167, 139, 250, 0.08)' },
+    logic: { accent: '#fbbf24', bg: 'rgba(251, 191, 36, 0.08)' },
+  };
+
+  const cat = categoryColors[data.category] || categoryColors.analyze;
+  const execStatus = $derived(data.executionStatus);
+  const statusText = $derived(data.statusText);
+
+  const configSummary = $derived.by(() => {
+    if (!data.config_schema || data.config_schema.length === 0) return null;
+    const required = data.config_schema.filter(f => f.required);
+    const missing = required.filter(f => {
+      const v = data.config?.[f.key];
+      return v === undefined || v === null || v === '';
+    });
+    if (missing.length > 0) return { status: 'missing', text: 'Needs configuration' };
+    const url = data.config?.repo_url;
+    if (url) {
+      const short = url.replace(/^https?:\/\//, '').replace(/\.git$/, '');
+      return { status: 'ok', text: short.length > 30 ? '...' + short.slice(-30) : short };
+    }
+    return { status: 'ok', text: 'Configured' };
+  });
+
+  // Dynamic border/shadow classes based on execution state
+  const nodeClasses = $derived.by(() => {
+    const base = 'rounded-[10px] min-w-[200px] font-sans shadow-md transition-all duration-150 overflow-hidden';
+    const bg = 'bg-[#1e1e2e] border border-[#2e2e42]';
+    const hover = 'hover:border-[#3e3e56] hover:shadow-lg';
+
+    if (execStatus === 'running') return `${base} ${bg} border-amber-500 shadow-[0_0_0_1px_#f59e0b,0_0_20px_rgba(245,158,11,0.15)]`;
+    if (execStatus === 'done') return `${base} ${bg} border-emerald-500 shadow-[0_0_0_1px_#10b981,0_0_20px_rgba(16,185,129,0.15)]`;
+    if (execStatus === 'error') return `${base} ${bg} border-red-500 shadow-[0_0_0_1px_#ef4444,0_0_20px_rgba(239,68,68,0.15)]`;
+    if (selected) return `${base} bg-[#1e1e2e] border shadow-lg`;
+    return `${base} ${bg} ${hover}`;
+  });
+</script>
+
+<div
+  class={nodeClasses}
+  style={selected && !execStatus ? `border-color: ${cat.accent}; box-shadow: 0 0 0 1px ${cat.accent}, 0 4px 16px rgba(0,0,0,0.35)` : ''}
+>
+  <!-- Header -->
+  <div class="flex items-center gap-2.5 px-3.5 py-2.5" style="background: {cat.bg}">
+    <div class="w-1 h-7 rounded-sm shrink-0" style="background: {cat.accent}"></div>
+    <div class="flex flex-col flex-1 min-w-0">
+      <span class="text-[13px] font-semibold text-[#e8e8ee] truncate leading-tight">{data.label}</span>
+      <span class="text-[10px] uppercase tracking-wide text-[#6e6e88] leading-tight">{data.category}</span>
+    </div>
+    {#if execStatus}
+      <div class="w-5 h-5 shrink-0 {execStatus === 'running' ? 'text-amber-500' : execStatus === 'done' ? 'text-emerald-500' : 'text-red-500'}">
+        {#if execStatus === 'running'}
+          <svg class="w-4 h-4 animate-spin" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6" stroke="currentColor" stroke-width="2" stroke-dasharray="28" stroke-dashoffset="8"/></svg>
+        {:else if execStatus === 'done'}
+          <svg class="w-4 h-4" viewBox="0 0 16 16" fill="none"><path d="M3 8.5L6.5 12L13 4" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>
+        {:else}
+          <svg class="w-4 h-4" viewBox="0 0 16 16" fill="none"><path d="M4 4L12 12M12 4L4 12" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>
+        {/if}
+      </div>
+    {/if}
+  </div>
+
+  <!-- Status text (running) -->
+  {#if execStatus === 'running' && statusText}
+    <div class="flex items-center gap-1.5 px-3.5 py-1.5 text-[10px] text-amber-500 border-t border-[#252540]">
+      <svg class="w-2.5 h-2.5 animate-spin shrink-0" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6" stroke="currentColor" stroke-width="2" stroke-dasharray="28" stroke-dashoffset="8"/></svg>
+      <span class="truncate">{statusText}</span>
+    </div>
+  {:else if configSummary}
+    <div class="flex items-center gap-1.5 px-3.5 py-1.5 text-[10px] border-t border-[#252540] {configSummary.status === 'missing' ? 'text-amber-500' : 'text-emerald-400'}">
+      {#if configSummary.status === 'missing'}
+        <svg class="w-3 h-3 shrink-0" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="7" stroke="currentColor" stroke-width="1.5"/><path d="M8 4.5V9" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><circle cx="8" cy="11.5" r="0.75" fill="currentColor"/></svg>
+      {:else}
+        <svg class="w-3 h-3 shrink-0" viewBox="0 0 16 16" fill="none"><path d="M3 8.5L6.5 12L13 4" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+      {/if}
+      <span class="truncate">{configSummary.text}</span>
+    </div>
+  {/if}
+
+  <!-- Ports -->
+  {#if data.input_ports?.length > 0 || data.output_ports?.length > 0}
+    <div class="py-1.5 pb-2">
+      {#if data.input_ports?.length > 0}
+        {#each data.input_ports as port}
+          <div class="flex items-center gap-1.5 px-3.5 py-0.5 text-[11px] relative">
+            <Handle
+              type="target"
+              position={Position.Left}
+              id={port.id}
+              style="background: {cat.accent}; border: 2px solid #1e1e2e; width: 12px; height: 12px; border-radius: 50%;"
+            />
+            <span class="text-[#b0b0c0]">{port.name}</span>
+            <span class="text-[#5e5e78] text-[10px] opacity-60">{port.data_type}</span>
+          </div>
+        {/each}
+      {/if}
+      {#if data.output_ports?.length > 0}
+        {#each data.output_ports as port}
+          <div class="flex items-center justify-end gap-1.5 px-3.5 py-0.5 text-[11px] relative">
+            <span class="text-[#5e5e78] text-[10px] opacity-60">{port.data_type}</span>
+            <span class="text-[#b0b0c0]">{port.name}</span>
+            <Handle
+              type="source"
+              position={Position.Right}
+              id={port.id}
+              style="background: {cat.accent}; border: 2px solid #1e1e2e; width: 12px; height: 12px; border-radius: 50%;"
+            />
+          </div>
+        {/each}
+      {/if}
+    </div>
+  {/if}
+</div>
diff --git a/apps/gitlock_phx/assets/svelte/workflow/panels/NodeConfigPanel.svelte b/apps/gitlock_phx/assets/svelte/workflow/panels/NodeConfigPanel.svelte
new file mode 100644
index 0000000..b984f36
--- /dev/null
+++ b/apps/gitlock_phx/assets/svelte/workflow/panels/NodeConfigPanel.svelte
@@ -0,0 +1,213 @@
+<script>
+  import { configPanelNode, flowCallbacks, flowNodes } from '../stores.js';
+
+  let node = $state(null);
+  let config = $state({});
+  let callbacks = $state({ onUpdateNodeConfig: () => {} });
+  let schema = $state([]);
+
+  configPanelNode.subscribe(v => {
+    node = v;
+    if (v) {
+      config = { ...(v.config || {}) };
+      schema = v.config_schema || [];
+    }
+  });
+  flowCallbacks.subscribe(v => { callbacks = v; });
+
+  function updateField(key, value, type) {
+    if (type === 'integer') {
+      config[key] = value === '' ? null : parseInt(value, 10);
+    } else if (type === 'date') {
+      config[key] = value === '' ? null : value;
+    } else {
+      config[key] = value;
+    }
+    if (node) {
+      callbacks.onUpdateNodeConfig(node.id, { ...config });
+      flowNodes.update(nodes =>
+        nodes.map(n =>
+          n.id === node.id
+            ? { ...n, data: { ...n.data, config: { ...config } } }
+            : n
+        )
+      );
+    }
+  }
+
+  function close() { configPanelNode.set(null); }
+
+  let hasRequiredFields = $derived(
+    schema.filter(f => f.required).every(f => {
+      const val = config[f.key];
+      return val !== undefined && val !== null && val !== '';
+    })
+  );
+
+  let parsedResult = $derived.by(() => {
+    if (!node?.result) return null;
+    try {
+      return typeof node.result === 'string' ? JSON.parse(node.result) : node.result;
+    } catch { return node.result; }
+  });
+
+  function formatValue(v) {
+    if (v === null || v === undefined) return '\u2014';
+    if (typeof v === 'number') return Number.isInteger(v) ? v.toString() : v.toFixed(3);
+    return String(v);
+  }
+
+  const catColors = { source: '#4ecdc4', analyze: '#ff6b35', output: '#a78bfa', logic: '#fbbf24' };
+</script>
+
+{#if node}
+  <aside class="w-80 bg-[#16162a] border-l border-[#252540] flex flex-col shrink-0 overflow-hidden">
+    <!-- Header -->
+    <div class="flex items-center justify-between px-4 py-3.5 border-b border-[#252540] shrink-0">
+      <div class="flex items-center gap-2.5 min-w-0">
+        <div class="w-1 h-7 rounded-sm shrink-0" style="background: {catColors[node.category] || '#888'}"></div>
+        <div>
+          <h3 class="text-sm font-semibold text-[#e0e0ee] m-0 leading-tight">{node.label}</h3>
+          <span class="text-[10px] uppercase tracking-wide text-[#5e5e78]">{node.category}</span>
+        </div>
+      </div>
+      <button
+        class="p-1.5 rounded-md text-[#5e5e78] hover:text-[#e0e0ee] hover:bg-[#252540] cursor-pointer bg-transparent border-none flex items-center shrink-0"
+        onclick={close}
+      >
+        <svg width="14" height="14" viewBox="0 0 14 14" fill="none"><path d="M1 1L13 13M13 1L1 13" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/></svg>
+      </button>
+    </div>
+
+    <div class="flex-1 overflow-y-auto">
+      <!-- Config fields -->
+      {#if schema.length > 0}
+        <div class="px-4 py-3.5 border-b border-[#1e1e30]">
+          <div class="text-[10px] font-semibold uppercase tracking-wide text-[#4e4e68] mb-2.5">Configuration</div>
+          {#each schema as field}
+            <div class="flex flex-col gap-1 mb-2.5">
+              <label for="cfg-{field.key}" class="text-xs font-medium text-[#8e8ea8]">
+                {field.label}
+                {#if field.required}<span class="text-red-400">*</span>{/if}
+              </label>
+              {#if field.type === 'select'}
+                <select
+                  id="cfg-{field.key}"
+                  value={config[field.key] ?? field.default ?? ''}
+                  onchange={(e) => updateField(field.key, e.target.value, field.type)}
+                  class="bg-[#1e1e2e] border border-[#2e2e48] text-[#e0e0ee] px-3 py-2 rounded-md text-[13px] font-sans outline-none transition-colors duration-100 w-full focus:border-indigo-500 placeholder:text-[#4e4e68]"
+                >
+                  {#each field.options || [] as opt}
+                    <option value={opt.value}>{opt.label}</option>
+                  {/each}
+                </select>
+              {:else if field.type === 'integer'}
+                <input
+                  id="cfg-{field.key}"
+                  type="number"
+                  value={config[field.key] ?? field.default ?? ''}
+                  placeholder={field.placeholder || ''}
+                  oninput={(e) => updateField(field.key, e.target.value, field.type)}
+                  class="bg-[#1e1e2e] border border-[#2e2e48] text-[#e0e0ee] px-3 py-2 rounded-md text-[13px] font-sans outline-none transition-colors duration-100 w-full focus:border-indigo-500 placeholder:text-[#4e4e68]"
+                />
+              {:else if field.type === 'date'}
+                <input
+                  id="cfg-{field.key}"
+                  type="date"
+                  value={config[field.key] ?? field.default ?? ''}
+                  oninput={(e) => updateField(field.key, e.target.value, field.type)}
+                  class="bg-[#1e1e2e] border border-[#2e2e48] text-[#e0e0ee] px-3 py-2 rounded-md text-[13px] font-sans outline-none transition-colors duration-100 w-full focus:border-indigo-500 placeholder:text-[#4e4e68]"
+                />
+              {:else}
+                <input
+                  id="cfg-{field.key}"
+                  type="text"
+                  value={config[field.key] ?? field.default ?? ''}
+                  placeholder={field.placeholder || ''}
+                  oninput={(e) => updateField(field.key, e.target.value, field.type)}
+                  class="bg-[#1e1e2e] border border-[#2e2e48] text-[#e0e0ee] px-3 py-2 rounded-md text-[13px] font-sans outline-none transition-colors duration-100 w-full focus:border-indigo-500 placeholder:text-[#4e4e68]"
+                />
+              {/if}
+            </div>
+          {/each}
+
+          {#if !hasRequiredFields}
+            <div class="flex items-center gap-2 text-[11px] text-amber-500 px-3 py-2 bg-amber-500/[0.08] border border-amber-500/[0.12] rounded-md">
+              <svg class="shrink-0" width="14" height="14" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="7" stroke="currentColor" stroke-width="1.5"/><path d="M8 4.5V9" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><circle cx="8" cy="11.5" r="0.75" fill="currentColor"/></svg>
+              Required fields missing
+            </div>
+          {/if}
+        </div>
+      {/if}
+
+      <!-- Execution results -->
+      {#if node.executionStatus === 'error'}
+        <div class="px-4 py-3.5 border-b border-[#1e1e30]">
+          <div class="text-[10px] font-semibold uppercase tracking-wide text-red-400 mb-2.5">Error</div>
+          <div class="bg-red-500/[0.08] border border-red-500/[0.12] rounded-md p-2.5">
+            <pre class="text-red-400 text-[11px] m-0 whitespace-pre-wrap break-words font-mono">{node.error || 'Unknown error'}</pre>
+          </div>
+        </div>
+      {:else if node.executionStatus === 'done' && parsedResult}
+        <div class="px-4 py-3.5 border-b border-[#1e1e30]">
+          <div class="text-[10px] font-semibold uppercase tracking-wide text-emerald-400 mb-2.5">Output</div>
+          {#if Array.isArray(parsedResult)}
+            <div class="text-[11px] text-[#5e5e78] mb-2">{parsedResult.length} result{parsedResult.length !== 1 ? 's' : ''}</div>
+            {#if parsedResult.length > 0}
+              <div class="overflow-x-auto">
+                <table class="w-full border-collapse text-[11px]">
+                  <thead>
+                    <tr>
+                      {#each Object.keys(parsedResult[0]) as col}
+                        <th class="text-left text-[#6e6e88] font-semibold px-2 py-1.5 border-b border-[#252540] whitespace-nowrap capitalize sticky top-0 bg-[#16162a]">{col.replace(/_/g, ' ')}</th>
+                      {/each}
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {#each parsedResult.slice(0, 50) as row}
+                      <tr class="hover:bg-[#1e1e2e]">
+                        {#each Object.values(row) as v}
+                          <td class="text-[#b0b0c0] px-2 py-1 border-b border-[#1e1e30] max-w-[160px] truncate" title={String(v)}>{formatValue(v)}</td>
+                        {/each}
+                      </tr>
+                    {/each}
+                  </tbody>
+                </table>
+                {#if parsedResult.length > 50}
+                  <div class="text-[#5e5e78] text-[11px] text-center py-1.5">Showing 50 of {parsedResult.length}</div>
+                {/if}
+              </div>
+            {/if}
+          {:else if typeof parsedResult === 'object'}
+            <div class="overflow-x-auto">
+              <table class="w-full border-collapse text-[11px]">
+                <tbody>
+                  {#each Object.entries(parsedResult) as [k, v]}
+                    <tr class="hover:bg-[#1e1e2e]">
+                      <th class="text-left w-[110px] text-purple-400 font-semibold px-2 py-1.5 border-b border-[#1e1e30] capitalize">{k.replace(/_/g, ' ')}</th>
+                      <td class="text-[#b0b0c0] px-2 py-1 border-b border-[#1e1e30]">{formatValue(v)}</td>
+                    </tr>
+                  {/each}
+                </tbody>
+              </table>
+            </div>
+          {:else}
+            <pre class="text-[#b0b0c0] text-[11px] m-0 whitespace-pre-wrap break-words font-mono bg-[#1e1e2e] p-2.5 rounded-md">{String(parsedResult)}</pre>
+          {/if}
+        </div>
+      {:else if node.executionStatus === 'running'}
+        <div class="px-4 py-3.5 border-b border-[#1e1e30]">
+          <div class="flex items-center gap-2 text-amber-500 text-xs py-2">
+            <svg class="w-4 h-4 animate-spin" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6" stroke="currentColor" stroke-width="2" stroke-dasharray="28" stroke-dashoffset="8"/></svg>
+            Running...
+          </div>
+        </div>
+      {/if}
+
+      <!-- Empty state -->
+      {#if schema.length === 0 && !node.executionStatus}
+        <div class="text-[#4e4e68] text-xs text-center px-4 py-8">Click Execute to run this node</div>
+      {/if}
+    </div>
+  </aside>
+{/if}
diff --git a/apps/gitlock_phx/assets/svelte/workflow/stores.js b/apps/gitlock_phx/assets/svelte/workflow/stores.js
new file mode 100644
index 0000000..1772124
--- /dev/null
+++ b/apps/gitlock_phx/assets/svelte/workflow/stores.js
@@ -0,0 +1,28 @@
+/**
+ * Shared state between the LiveView hook and Svelte components.
+ */
+import { writable } from 'svelte/store';
+
+/** @type {import('svelte/store').Writable<Array>} SvelteFlow-format nodes */
+export const flowNodes = writable([]);
+
+/** @type {import('svelte/store').Writable<Array>} SvelteFlow-format edges */
+export const flowEdges = writable([]);
+
+/** @type {import('svelte/store').Writable<Array>} Node catalog grouped by category */
+export const flowCatalog = writable([]);
+
+/** @type {import('svelte/store').Writable<Object|null>} Node selected for results display */
+export const selectedResultNode = writable(null);
+
+/** @type {import('svelte/store').Writable<Object|null>} Node selected for config editing */
+export const configPanelNode = writable(null);
+
+/** @type {import('svelte/store').Writable<Object>} Callbacks from Svelte → Hook */
+export const flowCallbacks = writable({
+  onConnect: (_connection) => {},
+  onNodeDragStop: (_nodeId, _position) => {},
+  onAddNode: (_typeId, _position) => {},
+  onDeleteElements: (_payload) => {},
+  onUpdateNodeConfig: (_nodeId, _config) => {},
+});
diff --git a/apps/gitlock_phx/lib/gitlock_phx/application.ex b/apps/gitlock_phx/lib/gitlock_phx/application.ex
index b4a6df6..3f0215c 100644
--- a/apps/gitlock_phx/lib/gitlock_phx/application.ex
+++ b/apps/gitlock_phx/lib/gitlock_phx/application.ex
@@ -12,8 +12,8 @@ defmodule GitlockPhx.Application do
       GitlockPhx.Repo,
       {DNSCluster, query: Application.get_env(:gitlock_phx, :dns_cluster_query) || :ignore},
       {Phoenix.PubSub, name: GitlockPhx.PubSub},
-      # Start a worker by calling: GitlockPhx.Worker.start_link(arg)
-      # {GitlockPhx.Worker, arg},
+      # Task supervisor for async pipeline execution
+      {Task.Supervisor, name: GitlockPhx.TaskSupervisor},
       # Start to serve requests, typically the last entry
       GitlockPhxWeb.Endpoint
     ]
diff --git a/apps/gitlock_phx/lib/gitlock_phx/pipeline/executor.ex b/apps/gitlock_phx/lib/gitlock_phx/pipeline/executor.ex
new file mode 100644
index 0000000..6f6d3aa
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx/pipeline/executor.ex
@@ -0,0 +1,16 @@
+# DEPRECATED: This module has moved to GitlockWorkflows.Executor
+# Delete this file and the pipeline/ directory.
+#
+# All references have been updated:
+#   - WorkflowLive uses GitlockWorkflows.Executor
+#   - AnalyzeLive uses GitlockWorkflows.Executor
+defmodule GitlockPhx.Pipeline.Executor do
+  @moduledoc false
+  @deprecated "Use GitlockWorkflows.Executor instead"
+
+  defdelegate run(pipeline, repo_path, caller \\ self(), options \\ %{}),
+    to: GitlockWorkflows.Executor
+
+  defdelegate run_sync(pipeline, repo_path, options \\ %{}),
+    to: GitlockWorkflows.Executor
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx/pipelines.ex b/apps/gitlock_phx/lib/gitlock_phx/pipelines.ex
new file mode 100644
index 0000000..964abbc
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx/pipelines.ex
@@ -0,0 +1,262 @@
+defmodule GitlockPhx.Pipelines do
+  @moduledoc """
+  Context for managing saved pipelines and execution runs.
+  Bridges between the in-memory GitlockWorkflows.Pipeline and the database.
+  """
+
+  import Ecto.Query
+  alias GitlockPhx.Repo
+  alias GitlockPhx.Pipelines.{SavedPipeline, PipelineRun}
+  alias GitlockWorkflows.{Pipeline, Node, Edge, Port, NodeCatalog, Serializer, Templates}
+
+  # ── Pipeline CRUD ────────────────────────────────────────────
+
+  def list_pipelines(user_id) do
+    SavedPipeline
+    |> where(user_id: ^user_id, is_template: false)
+    |> order_by(desc: :updated_at)
+    |> Repo.all()
+  end
+
+  def list_templates do
+    SavedPipeline
+    |> where(is_template: true)
+    |> order_by(:name)
+    |> Repo.all()
+  end
+
+  def get_pipeline!(id), do: Repo.get!(SavedPipeline, id)
+
+  def save_pipeline(user_id, %Pipeline{} = pipeline) do
+    config = Serializer.to_map(pipeline)
+
+    %SavedPipeline{}
+    |> SavedPipeline.changeset(%{
+      name: pipeline.name,
+      description: pipeline.description,
+      config: config,
+      user_id: user_id
+    })
+    |> Repo.insert()
+  end
+
+  def update_pipeline(%SavedPipeline{} = saved, %Pipeline{} = pipeline) do
+    config = Serializer.to_map(pipeline)
+
+    saved
+    |> SavedPipeline.changeset(%{
+      name: pipeline.name,
+      description: pipeline.description,
+      config: config
+    })
+    |> Repo.update()
+  end
+
+  def delete_pipeline(%SavedPipeline{} = saved) do
+    Repo.delete(saved)
+  end
+
+  @doc "Converts a saved pipeline DB record back to a workflow Pipeline struct."
+  def to_workflow(%SavedPipeline{config: config}) do
+    hydrate_pipeline(config)
+  end
+
+  # ── Pipeline Runs ────────────────────────────────────────────
+
+  def create_run(pipeline_id, user_id, repo_url) do
+    %PipelineRun{}
+    |> PipelineRun.changeset(%{
+      pipeline_id: pipeline_id,
+      user_id: user_id,
+      repo_url: repo_url,
+      status: "running",
+      started_at: DateTime.utc_now()
+    })
+    |> Repo.insert()
+  end
+
+  def complete_run(%PipelineRun{} = run, results) do
+    run
+    |> PipelineRun.changeset(%{
+      status: "completed",
+      results: results,
+      completed_at: DateTime.utc_now()
+    })
+    |> Repo.update()
+  end
+
+  def fail_run(%PipelineRun{} = run, error) do
+    run
+    |> PipelineRun.changeset(%{
+      status: "failed",
+      error: to_string(error),
+      completed_at: DateTime.utc_now()
+    })
+    |> Repo.update()
+  end
+
+  @doc "Finishes a run with status, results, and optional error. Stores partial results even on failure."
+  def finish_run(%PipelineRun{} = run, status, results, error \\ nil) do
+    run
+    |> PipelineRun.changeset(%{
+      status: status,
+      results: results,
+      error: if(error, do: to_string(error)),
+      completed_at: DateTime.utc_now()
+    })
+    |> Repo.update()
+  end
+
+  def list_runs(pipeline_id) do
+    PipelineRun
+    |> where(pipeline_id: ^pipeline_id)
+    |> order_by(desc: :inserted_at)
+    |> limit(20)
+    |> Repo.all()
+  end
+
+  def list_runs_for_user(user_id, opts \\ []) do
+    limit_val = Keyword.get(opts, :limit, 50)
+
+    PipelineRun
+    |> where(user_id: ^user_id)
+    |> order_by(desc: :inserted_at)
+    |> limit(^limit_val)
+    |> preload(:pipeline)
+    |> Repo.all()
+  end
+
+  def get_run!(id), do: Repo.get!(PipelineRun, id)
+
+  def get_run_with_pipeline!(id) do
+    PipelineRun
+    |> preload(:pipeline)
+    |> Repo.get!(id)
+  end
+
+  # ── Templates ────────────────────────────────────────────────
+
+  @doc "Seeds built-in pipeline templates. Idempotent."
+  def seed_templates! do
+    for template_info <- Templates.list() do
+      pipeline = Templates.build(template_info.id)
+      now = DateTime.utc_now() |> DateTime.truncate(:second)
+      config = Serializer.to_map(pipeline)
+
+      case Repo.one(
+             from p in SavedPipeline,
+               where: p.name == ^template_info.name and p.is_template == true
+           ) do
+        nil ->
+          Repo.insert!(%SavedPipeline{
+            name: template_info.name,
+            description: template_info.description,
+            config: config,
+            is_template: true,
+            user_id: nil,
+            inserted_at: now,
+            updated_at: now
+          })
+
+        existing ->
+          existing
+          |> SavedPipeline.changeset(%{
+            description: template_info.description,
+            config: config
+          })
+          |> Repo.update!()
+      end
+    end
+  end
+
+  # ── Hydration ────────────────────────────────────────────────
+
+  defp hydrate_pipeline(config) when is_map(config) do
+    pipeline = Pipeline.new(config["name"] || "Untitled")
+    pipeline = %{pipeline | id: config["id"] || pipeline.id}
+
+    nodes =
+      (config["nodes"] || %{})
+      |> Enum.map(fn {_id, node_data} -> hydrate_node(node_data) end)
+      |> Enum.reject(&is_nil/1)
+
+    pipeline =
+      Enum.reduce(nodes, pipeline, fn node, acc ->
+        case Pipeline.add_node(acc, node) do
+          {:error, _} -> acc
+          p -> p
+        end
+      end)
+
+    edges =
+      (config["edges"] || %{})
+      |> Enum.map(fn {_id, edge_data} -> hydrate_edge(edge_data, pipeline) end)
+      |> Enum.reject(&is_nil/1)
+
+    Enum.reduce(edges, pipeline, fn edge, acc ->
+      case Pipeline.add_edge(acc, edge) do
+        {:error, _} -> acc
+        p -> p
+      end
+    end)
+  end
+
+  defp hydrate_node(data) do
+    type = data["type"] |> to_string() |> String.to_existing_atom()
+    [x, y] = data["position"] || [0, 0]
+
+    case NodeCatalog.get_type(type) do
+      {:ok, type_def} ->
+        %Node{
+          id: data["id"],
+          type: type,
+          label: data["label"] || type_def.label,
+          config: data["config"] || %{},
+          position: {x, y},
+          input_ports: rebuild_ports(data["input_ports"], type_def.input_ports),
+          output_ports: rebuild_ports(data["output_ports"], type_def.output_ports)
+        }
+
+      {:error, _} ->
+        nil
+    end
+  rescue
+    _ -> nil
+  end
+
+  # Rebuild ports from the catalog definition (source of truth),
+  # preserving stored port IDs where names match so edges stay valid.
+  defp rebuild_ports(stored_ports, catalog_ports) do
+    stored_by_name =
+      (stored_ports || [])
+      |> Map.new(fn p -> {p["name"], p["id"]} end)
+
+    Enum.map(catalog_ports, fn catalog_port ->
+      optional = Map.get(catalog_port, :optional, false)
+
+      # Reuse stored ID if this port existed before, otherwise generate new
+      id =
+        Map.get(stored_by_name, catalog_port.name) ||
+          :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
+
+      %Port{
+        id: id,
+        name: catalog_port.name,
+        data_type: catalog_port.data_type,
+        optional: optional
+      }
+    end)
+  end
+
+  defp hydrate_edge(data, _pipeline) do
+    %Edge{
+      id: data["id"] || :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower),
+      source_node_id: data["source_node_id"],
+      source_port_id: data["source_port_id"],
+      target_node_id: data["target_node_id"],
+      target_port_id: data["target_port_id"]
+    }
+  rescue
+    _ -> nil
+  end
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx/pipelines/pipeline_run.ex b/apps/gitlock_phx/lib/gitlock_phx/pipelines/pipeline_run.ex
new file mode 100644
index 0000000..d85eb9b
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx/pipelines/pipeline_run.ex
@@ -0,0 +1,36 @@
+defmodule GitlockPhx.Pipelines.PipelineRun do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "pipeline_runs" do
+    field :repo_url, :string
+    field :status, :string, default: "running"
+    field :results, :map, default: %{}
+    field :error, :string
+    field :started_at, :utc_datetime
+    field :completed_at, :utc_datetime
+
+    belongs_to :pipeline, GitlockPhx.Pipelines.SavedPipeline
+    belongs_to :user, GitlockPhx.Accounts.User
+
+    timestamps(type: :utc_datetime)
+  end
+
+  def changeset(run, attrs) do
+    run
+    |> cast(attrs, [
+      :repo_url,
+      :status,
+      :results,
+      :error,
+      :started_at,
+      :completed_at,
+      :pipeline_id,
+      :user_id
+    ])
+    |> validate_required([:repo_url, :status, :pipeline_id, :user_id])
+    |> validate_inclusion(:status, ~w(running completed failed))
+    |> foreign_key_constraint(:pipeline_id)
+    |> foreign_key_constraint(:user_id)
+  end
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx/pipelines/saved_pipeline.ex b/apps/gitlock_phx/lib/gitlock_phx/pipelines/saved_pipeline.ex
new file mode 100644
index 0000000..cbbe261
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx/pipelines/saved_pipeline.ex
@@ -0,0 +1,33 @@
+defmodule GitlockPhx.Pipelines.SavedPipeline do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "pipelines" do
+    field :name, :string
+    field :description, :string, default: ""
+    field :config, :map, default: %{}
+    field :is_template, :boolean, default: false
+
+    belongs_to :user, GitlockPhx.Accounts.User
+    has_many :runs, GitlockPhx.Pipelines.PipelineRun
+
+    timestamps(type: :utc_datetime)
+  end
+
+  def changeset(pipeline, attrs) do
+    pipeline
+    |> cast(attrs, [:name, :description, :config, :is_template, :user_id])
+    |> validate_required([:name, :config])
+    |> validate_length(:name, min: 1, max: 100)
+    |> maybe_require_user()
+    |> foreign_key_constraint(:user_id)
+  end
+
+  defp maybe_require_user(changeset) do
+    if get_field(changeset, :is_template) do
+      changeset
+    else
+      validate_required(changeset, [:user_id])
+    end
+  end
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx/release.ex b/apps/gitlock_phx/lib/gitlock_phx/release.ex
index 057efae..d7b316d 100644
--- a/apps/gitlock_phx/lib/gitlock_phx/release.ex
+++ b/apps/gitlock_phx/lib/gitlock_phx/release.ex
@@ -11,6 +11,17 @@ defmodule GitlockPhx.Release do
     for repo <- repos() do
       {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
     end
+
+    seed()
+  end
+
+  def seed do
+    load_app()
+
+    {:ok, _, _} =
+      Ecto.Migrator.with_repo(GitlockPhx.Repo, fn _repo ->
+        GitlockPhx.Pipelines.seed_templates!()
+      end)
   end
 
   def rollback(repo, version) do
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/components/layouts/root.html.heex b/apps/gitlock_phx/lib/gitlock_phx_web/components/layouts/root.html.heex
index 4f6d210..33a8f71 100644
--- a/apps/gitlock_phx/lib/gitlock_phx_web/components/layouts/root.html.heex
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/components/layouts/root.html.heex
@@ -24,6 +24,7 @@
       })();
     </script>
     <link phx-track-static rel="stylesheet" href={~p"/assets/css/app.css"} />
+    <link phx-track-static rel="stylesheet" href={~p"/assets/js/app.css"} />
     <link rel="icon" href={~p"/icons/favicon.svg"} type="image/svg+xml" />
     <script defer phx-track-static type="text/javascript" src={~p"/assets/js/app.js"}>
     </script>
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/live/analyze_live.ex b/apps/gitlock_phx/lib/gitlock_phx_web/live/analyze_live.ex
new file mode 100644
index 0000000..9558ec8
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/live/analyze_live.ex
@@ -0,0 +1,442 @@
+defmodule GitlockPhxWeb.AnalyzeLive do
+  use GitlockPhxWeb, :live_view
+
+  alias GitlockPhx.Pipelines
+  alias GitlockPhx.Pipelines.PipelineRun
+  alias GitlockWorkflows.{Pipeline, Executor}
+  alias GitlockPhxWeb.ResultSerializer
+
+  @impl true
+  def mount(_params, _session, socket) do
+    templates = Pipelines.list_templates()
+
+    {:ok,
+     assign(socket,
+       templates: templates,
+       selected_template: nil,
+       repo_url: "",
+       execution: :idle,
+       node_progress: %{},
+       results: %{},
+       parsed_results: [],
+       pipeline: nil,
+       current_run: nil,
+       error: nil,
+       page_title: "Analyze Repository"
+     )}
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div class="analyze-page">
+      <div class="analyze-container">
+        <header class="analyze-header">
+          <h1>Analyze a Repository</h1>
+          <p class="analyze-subtitle">
+            Paste a Git URL or local path to discover hotspots, knowledge silos, and technical debt.
+          </p>
+        </header>
+
+        <div class="analyze-form">
+          <form phx-submit="run_analysis" phx-change="form_change">
+            <div class="form-group">
+              <label for="repo_url">Repository</label>
+              <input
+                type="text"
+                id="repo_url"
+                name="repo_url"
+                value={@repo_url}
+                placeholder="https://github.com/org/repo or /path/to/local/repo"
+                class="analyze-input"
+                phx-debounce="300"
+                autofocus
+              />
+            </div>
+
+            <div class="form-group">
+              <label>Analysis Template</label>
+              <div class="template-grid">
+                <%= for tpl <- @templates do %>
+                  <button
+                    type="button"
+                    class={"template-card #{if @selected_template && @selected_template.id == tpl.id, do: "selected", else: ""}"}
+                    phx-click="select_template"
+                    phx-value-id={tpl.id}
+                  >
+                    <span class="template-name">{tpl.name}</span>
+                    <span class="template-desc">{tpl.description}</span>
+                    <span class="template-nodes">{map_size(tpl.config["nodes"] || %{})} steps</span>
+                  </button>
+                <% end %>
+              </div>
+            </div>
+
+            <button
+              type="submit"
+              class={"analyze-submit #{if @execution == :running, do: "running"}"}
+              disabled={@repo_url == "" or @selected_template == nil or @execution == :running}
+            >
+              {submit_label(@execution)}
+            </button>
+          </form>
+        </div>
+
+        <%= if @execution == :running do %>
+          <div class="analyze-progress">
+            <h2>Running Analysis</h2>
+            <div class="progress-nodes">
+              <%= for {node_id, status} <- @node_progress do %>
+                <div class={"progress-node #{status_class(status)}"}>
+                  <span class="progress-indicator">{status_icon(status)}</span>
+                  <span class="progress-label">{node_label(node_id, @pipeline)}</span>
+                  <%= if status_text(status) do %>
+                    <span class="progress-status-text">{status_text(status)}</span>
+                  <% end %>
+                </div>
+              <% end %>
+            </div>
+          </div>
+        <% end %>
+
+        <%= if @execution == :done and length(@parsed_results) > 0 do %>
+          <div class="analyze-results">
+            <h2>Results</h2>
+            <%= for %{label: label, status: :ok, rows: rows, columns: cols} <- @parsed_results do %>
+              <div class="result-card">
+                <div class="result-card-header">
+                  <h3>{label}</h3>
+                  <span class="result-count">{length(rows)} row{if length(rows) != 1, do: "s"}</span>
+                </div>
+                <div class="result-table-wrap">
+                  <table class="result-table">
+                    <thead>
+                      <tr>
+                        <%= for col <- cols do %>
+                          <th>{format_column(col)}</th>
+                        <% end %>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      <%= for row <- Enum.take(rows, 30) do %>
+                        <tr>
+                          <%= for col <- cols do %>
+                            <td title={to_string(Map.get(row, col, ""))}>
+                              {format_cell(Map.get(row, col))}
+                            </td>
+                          <% end %>
+                        </tr>
+                      <% end %>
+                    </tbody>
+                  </table>
+                  <%= if length(rows) > 30 do %>
+                    <p class="result-truncated">Showing 30 of {length(rows)} rows</p>
+                  <% end %>
+                </div>
+              </div>
+            <% end %>
+
+            <%= for %{label: label, status: :error, error: reason} <- @parsed_results do %>
+              <div class="result-card error">
+                <h3>{label}</h3>
+                <pre class="result-error">{reason}</pre>
+              </div>
+            <% end %>
+          </div>
+        <% end %>
+
+        <%= if @error do %>
+          <div class="analyze-error">
+            <p>{@error}</p>
+          </div>
+        <% end %>
+      </div>
+    </div>
+    """
+  end
+
+  @impl true
+  def handle_event("form_change", %{"repo_url" => url}, socket) do
+    {:noreply, assign(socket, repo_url: String.trim(url))}
+  end
+
+  def handle_event("select_template", %{"id" => id}, socket) do
+    template = Enum.find(socket.assigns.templates, &(to_string(&1.id) == id))
+    {:noreply, assign(socket, selected_template: template)}
+  end
+
+  def handle_event("run_analysis", _params, socket) do
+    template = socket.assigns.selected_template
+    repo_url = socket.assigns.repo_url
+
+    if template == nil or repo_url == "" do
+      {:noreply, assign(socket, error: "Select a template and enter a repository URL")}
+    else
+      pipeline = Pipelines.to_workflow(template)
+
+      # Persist run for logged-in users
+      run = maybe_create_run(socket, template, repo_url)
+
+      Executor.run(pipeline, repo_url, self(), %{format: "json"})
+
+      {:noreply,
+       assign(socket,
+         pipeline: pipeline,
+         current_run: run,
+         execution: :running,
+         node_progress: %{},
+         results: %{},
+         parsed_results: [],
+         error: nil
+       )}
+    end
+  end
+
+  @impl true
+  def handle_info({:pipeline_progress, node_id, :running}, socket) do
+    progress = Map.put(socket.assigns.node_progress, node_id, :running)
+    {:noreply, assign(socket, node_progress: progress)}
+  end
+
+  def handle_info({:pipeline_progress, node_id, {:status, message}}, socket) do
+    progress = Map.put(socket.assigns.node_progress, node_id, {:running, message})
+    {:noreply, assign(socket, node_progress: progress)}
+  end
+
+  def handle_info({:pipeline_progress, node_id, {:done, _result}}, socket) do
+    progress = Map.put(socket.assigns.node_progress, node_id, :done)
+    {:noreply, assign(socket, node_progress: progress)}
+  end
+
+  def handle_info({:pipeline_progress, node_id, {:error, _reason}}, socket) do
+    progress = Map.put(socket.assigns.node_progress, node_id, :error)
+    {:noreply, assign(socket, node_progress: progress)}
+  end
+
+  def handle_info({:pipeline_complete, results}, socket) do
+    serialized = ResultSerializer.serialize_results(results)
+    parsed = parse_results(serialized, socket.assigns.pipeline)
+
+    # Persist run results
+    persist_run_results(socket.assigns[:current_run], results)
+
+    {:noreply,
+     assign(socket,
+       execution: :done,
+       results: serialized,
+       parsed_results: parsed,
+       current_run: nil
+     )}
+  end
+
+  # ── Parse execution results into display-ready structs ───────
+
+  defp parse_results(results, pipeline) do
+    results
+    |> Enum.map(fn {node_id, outcome} ->
+      label = node_label(node_id, pipeline)
+
+      case outcome do
+        {:ok, %{data: data}} ->
+          parse_success(label, data)
+
+        {:ok, data} ->
+          parse_success(label, data)
+
+        {:error, reason} ->
+          %{label: label, status: :error, error: inspect(reason), rows: [], columns: []}
+      end
+    end)
+    |> Enum.sort_by(& &1.label)
+  end
+
+  defp parse_success(label, data) when is_binary(data) do
+    case Jason.decode(data) do
+      {:ok, rows} when is_list(rows) and length(rows) > 0 ->
+        cols = rows |> List.first() |> Map.keys() |> prioritize_columns()
+        %{label: label, status: :ok, rows: rows, columns: cols}
+
+      {:ok, map} when is_map(map) ->
+        rows = Enum.map(map, fn {k, v} -> %{"field" => k, "value" => format_cell(v)} end)
+        %{label: label, status: :ok, rows: rows, columns: ["field", "value"]}
+
+      _ ->
+        %{label: label, status: :ok, rows: [%{"output" => data}], columns: ["output"]}
+    end
+  end
+
+  defp parse_success(label, data) when is_list(data) and length(data) > 0 do
+    rows =
+      Enum.map(data, fn
+        %{__struct__: _} = s -> Map.from_struct(s) |> stringify_keys()
+        m when is_map(m) -> stringify_keys(m)
+        other -> %{"value" => inspect(other)}
+      end)
+
+    cols = rows |> List.first() |> Map.keys() |> prioritize_columns()
+    %{label: label, status: :ok, rows: rows, columns: cols}
+  end
+
+  defp parse_success(label, data) when is_map(data) and not is_struct(data) do
+    # Check if this is a port-keyed output map (e.g., %{hotspots: [...]})
+    # After ResultSerializer, keys are strings and structs are plain maps
+    values = Map.values(data)
+
+    case values do
+      [list] when is_list(list) and length(list) > 0 ->
+        # Single port output with a list — display the list as a table
+        parse_success(label, list)
+
+      [single] when is_map(single) ->
+        # Single port output with a map — display as key-value
+        rows =
+          Enum.map(single, fn {k, v} -> %{"field" => to_string(k), "value" => format_cell(v)} end)
+
+        %{label: label, status: :ok, rows: rows, columns: ["field", "value"]}
+
+      _ ->
+        # Multi-port or other map — show as key-value pairs
+        rows =
+          Enum.map(data, fn {k, v} -> %{"field" => to_string(k), "value" => format_cell(v)} end)
+
+        %{label: label, status: :ok, rows: rows, columns: ["field", "value"]}
+    end
+  end
+
+  defp parse_success(label, data) do
+    %{label: label, status: :ok, rows: [%{"output" => inspect(data)}], columns: ["output"]}
+  end
+
+  defp stringify_keys(map) do
+    Map.new(map, fn {k, v} -> {to_string(k), v} end)
+  end
+
+  # Put the most important columns first
+  defp prioritize_columns(cols) do
+    priority =
+      ~w(file path name entity label author changes revisions complexity score risk normalized_score percentile)
+
+    {front, rest} =
+      Enum.split_with(cols, fn c ->
+        String.downcase(c) in priority
+      end)
+
+    sorted_front =
+      Enum.sort_by(front, fn c ->
+        Enum.find_index(priority, &(&1 == String.downcase(c))) || 999
+      end)
+
+    sorted_front ++ Enum.sort(rest)
+  end
+
+  # ── Run persistence ─────────────────────────────────────────
+
+  defp current_user(%{assigns: %{current_scope: %{user: %{id: _} = user}}}), do: user
+  defp current_user(_), do: nil
+
+  defp maybe_create_run(socket, template, repo_url) do
+    case current_user(socket) do
+      nil ->
+        nil
+
+      user ->
+        case Pipelines.create_run(template.id, user.id, repo_url) do
+          {:ok, run} -> run
+          {:error, _} -> nil
+        end
+    end
+  end
+
+  defp persist_run_results(nil, _results), do: :ok
+
+  defp persist_run_results(%PipelineRun{} = run, results) do
+    storable = ResultSerializer.serialize_for_storage(results)
+
+    failures =
+      results
+      |> Map.values()
+      |> Enum.filter(fn
+        {:error, _} -> true
+        _ -> false
+      end)
+
+    {status, error} =
+      case failures do
+        [] ->
+          {"completed", nil}
+
+        _ ->
+          error_msg = failures |> Enum.map(fn {:error, r} -> inspect(r) end) |> Enum.join("; ")
+          {"failed", error_msg}
+      end
+
+    Pipelines.finish_run(run, status, storable, error)
+  end
+
+  # ── Helpers ──────────────────────────────────────────────
+
+  defp submit_label(:idle), do: "Run Analysis"
+  defp submit_label(:running), do: "Running..."
+  defp submit_label(:done), do: "Run Again"
+
+  defp status_class({:running, _}), do: "running"
+  defp status_class(:running), do: "running"
+  defp status_class(:done), do: "done"
+  defp status_class(:error), do: "error"
+  defp status_class(_), do: ""
+
+  defp status_text({:running, msg}) when is_binary(msg), do: msg
+  defp status_text(_), do: nil
+
+  defp status_icon({:running, _}), do: status_icon(:running)
+
+  defp status_icon(:running),
+    do:
+      raw(
+        ~s[<svg class="status-spin" width="14" height="14" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6" stroke="currentColor" stroke-width="2" stroke-dasharray="28" stroke-dashoffset="8"/></svg>]
+      )
+
+  defp status_icon(:done),
+    do:
+      raw(
+        ~s[<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M3 8.5L6.5 12L13 4" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>]
+      )
+
+  defp status_icon(:error),
+    do:
+      raw(
+        ~s[<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M4 4L12 12M12 4L4 12" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>]
+      )
+
+  defp status_icon(_),
+    do:
+      raw(
+        ~s[<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="5" stroke="currentColor" stroke-width="1.5"/></svg>]
+      )
+
+  defp node_label(node_id, %Pipeline{nodes: nodes}) do
+    case Map.get(nodes, node_id) do
+      nil -> node_id
+      node -> node.label
+    end
+  end
+
+  defp node_label(node_id, _), do: node_id
+
+  defp format_column(col) do
+    col
+    |> String.replace("_", " ")
+    |> String.split(" ")
+    |> Enum.map(&String.capitalize/1)
+    |> Enum.join(" ")
+  end
+
+  defp format_cell(nil), do: "—"
+  defp format_cell(v) when is_float(v), do: :erlang.float_to_binary(v, decimals: 3)
+  defp format_cell(v) when is_integer(v), do: Integer.to_string(v)
+  defp format_cell(v) when is_binary(v), do: v
+  defp format_cell(v) when is_atom(v), do: Atom.to_string(v)
+  defp format_cell(v) when is_list(v), do: Enum.join(Enum.map(v, &to_string/1), ", ")
+  defp format_cell(v) when is_map(v), do: inspect(v, limit: 5)
+  defp format_cell(v), do: inspect(v)
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/live/pipelines_live.ex b/apps/gitlock_phx/lib/gitlock_phx_web/live/pipelines_live.ex
new file mode 100644
index 0000000..2acd0f0
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/live/pipelines_live.ex
@@ -0,0 +1,155 @@
+defmodule GitlockPhxWeb.PipelinesLive do
+  use GitlockPhxWeb, :live_view
+
+  alias GitlockPhx.Pipelines
+
+  @impl true
+  def mount(_params, _session, socket) do
+    user = current_user(socket)
+
+    pipelines = if user, do: Pipelines.list_pipelines(user.id), else: []
+    templates = Pipelines.list_templates()
+
+    {:ok,
+     assign(socket,
+       pipelines: pipelines,
+       templates: templates,
+       page_title: "My Pipelines"
+     )}
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div class="pipelines-page">
+      <div class="pipelines-container">
+        <header class="pipelines-header">
+          <h1>Pipelines</h1>
+          <.link navigate={~p"/workflows"} class="btn btn-execute">
+            + New Pipeline
+          </.link>
+        </header>
+
+        <%= if current_user(assigns) do %>
+          <%= if length(@pipelines) > 0 do %>
+            <section class="pipelines-section">
+              <h2>My Pipelines</h2>
+              <div class="pipelines-grid">
+                <%= for p <- @pipelines do %>
+                  <div class="pipeline-card">
+                    <div class="pipeline-card-body">
+                      <h3>
+                        <.link navigate={~p"/workflows/#{p.id}"}>{p.name}</.link>
+                      </h3>
+                      <p class="pipeline-desc">{p.description || "No description"}</p>
+                      <div class="pipeline-meta">
+                        <span>{node_count(p)} nodes</span>
+                        <span>Updated {format_time(p.updated_at)}</span>
+                      </div>
+                    </div>
+                    <div class="pipeline-card-actions">
+                      <.link navigate={~p"/workflows/#{p.id}"} class="btn btn-secondary btn-sm">
+                        Open
+                      </.link>
+                      <button
+                        phx-click="delete"
+                        phx-value-id={p.id}
+                        data-confirm="Delete this pipeline?"
+                        class="btn btn-danger btn-sm"
+                      >
+                        Delete
+                      </button>
+                    </div>
+                  </div>
+                <% end %>
+              </div>
+            </section>
+          <% else %>
+            <section class="pipelines-empty">
+              <p>No saved pipelines yet.</p>
+              <p>
+                <.link navigate={~p"/workflows"}>Create a new pipeline</.link>
+                or load a template to get started.
+              </p>
+            </section>
+          <% end %>
+        <% else %>
+          <section class="pipelines-empty">
+            <p>
+              <.link navigate={~p"/users/log-in"}>Log in</.link> to save and manage your pipelines.
+            </p>
+          </section>
+        <% end %>
+
+        <section class="pipelines-section">
+          <h2>Templates</h2>
+          <div class="pipelines-grid">
+            <%= for t <- @templates do %>
+              <div class="pipeline-card template">
+                <div class="pipeline-card-body">
+                  <h3>
+                    <.link navigate={~p"/workflows"} phx-click="load_template" phx-value-id={t.id}>
+                      {t.name}
+                    </.link>
+                  </h3>
+                  <p class="pipeline-desc">{t.description}</p>
+                  <div class="pipeline-meta">
+                    <span>{node_count(t)} nodes</span>
+                    <span class="template-badge">Template</span>
+                  </div>
+                </div>
+              </div>
+            <% end %>
+          </div>
+        </section>
+      </div>
+    </div>
+    """
+  end
+
+  @impl true
+  def handle_event("delete", %{"id" => id}, socket) do
+    user = current_user(socket)
+
+    if user do
+      saved = Pipelines.get_pipeline!(String.to_integer(id))
+
+      if saved.user_id == user.id do
+        Pipelines.delete_pipeline(saved)
+        pipelines = Pipelines.list_pipelines(user.id)
+        {:noreply, socket |> assign(pipelines: pipelines) |> put_flash(:info, "Pipeline deleted")}
+      else
+        {:noreply, put_flash(socket, :error, "Not authorized")}
+      end
+    else
+      {:noreply, put_flash(socket, :error, "Log in to manage pipelines")}
+    end
+  end
+
+  defp current_user(%{assigns: %{current_scope: %{user: user}}}) when not is_nil(user), do: user
+  defp current_user(_), do: nil
+
+  defp node_count(%{config: %{"nodes" => nodes}}) when is_map(nodes), do: map_size(nodes)
+
+  defp node_count(%{config: config}) when is_map(config) do
+    case Map.get(config, :nodes) || Map.get(config, "nodes") do
+      nodes when is_map(nodes) -> map_size(nodes)
+      _ -> 0
+    end
+  end
+
+  defp node_count(_), do: 0
+
+  defp format_time(dt) do
+    now = DateTime.utc_now()
+    diff = DateTime.diff(now, dt, :second)
+
+    cond do
+      diff < 60 -> "just now"
+      diff < 3600 -> "#{div(diff, 60)}m ago"
+      diff < 86400 -> "#{div(diff, 3600)}h ago"
+      diff < 604_800 -> "#{div(diff, 86400)}d ago"
+      true -> Calendar.strftime(dt, "%b %d, %Y")
+    end
+  end
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/live/result_serializer.ex b/apps/gitlock_phx/lib/gitlock_phx_web/live/result_serializer.ex
new file mode 100644
index 0000000..063d06a
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/live/result_serializer.ex
@@ -0,0 +1,108 @@
+defmodule GitlockPhxWeb.ResultSerializer do
+  @moduledoc """
+  Converts raw runtime node output into JSON-safe maps for the frontend.
+
+  Runtime nodes return port-keyed maps like `%{hotspots: [%Hotspot{...}, ...]}`.
+  This module:
+  - Extracts the primary data from single-port output maps
+  - Converts structs to plain string-keyed maps
+  - Ensures all values are JSON-serializable
+  """
+
+  @doc """
+  Serializes runtime node output for push_event to Svelte.
+
+  If the output is a single-key map (typical port output like `%{hotspots: [...]}`),
+  extracts the inner value. Converts all structs to plain maps with string keys.
+  """
+  @spec serialize(term()) :: term()
+  def serialize(output) when is_map(output) and not is_struct(output) do
+    case Map.to_list(output) do
+      # Single port output — extract the value directly
+      [{_port, value}] ->
+        serialize_value(value)
+
+      # Multiple ports — serialize each value
+      pairs when length(pairs) > 1 ->
+        Map.new(pairs, fn {k, v} -> {to_string(k), serialize_value(v)} end)
+
+      [] ->
+        %{}
+    end
+  end
+
+  def serialize(output), do: serialize_value(output)
+
+  @doc """
+  Serializes the complete results map from pipeline_complete.
+
+  Results are `%{node_id => {:ok, %{data: output}} | {:error, reason}}`.
+  """
+  @spec serialize_results(map()) :: map()
+  def serialize_results(results) when is_map(results) do
+    Map.new(results, fn
+      {node_id, {:ok, %{data: data} = meta}} ->
+        {node_id, {:ok, %{meta | data: serialize(data)}}}
+
+      {node_id, other} ->
+        {node_id, other}
+    end)
+  end
+
+  @doc """
+  Serializes results into a fully JSON-safe map for database storage.
+
+  Converts `{:ok, ...}` / `{:error, ...}` tuples into plain maps with
+  a `"status"` key, suitable for JSONB columns.
+  """
+  @spec serialize_for_storage(map()) :: map()
+  def serialize_for_storage(results) when is_map(results) do
+    Map.new(results, fn
+      {node_id, {:ok, %{data: data} = meta}} ->
+        {node_id,
+         %{
+           "status" => "ok",
+           "node_id" => to_string(Map.get(meta, :node_id, node_id)),
+           "type" => to_string(Map.get(meta, :type, "unknown")),
+           "label" => to_string(Map.get(meta, :label, node_id)),
+           "data" => serialize(data)
+         }}
+
+      {node_id, {:error, reason}} ->
+        {node_id,
+         %{
+           "status" => "error",
+           "error" => to_string(reason)
+         }}
+
+      {node_id, _other} ->
+        {node_id, %{"status" => "unknown"}}
+    end)
+  end
+
+  # ── Private ──────────────────────────────────────────────────
+
+  defp serialize_value(list) when is_list(list) do
+    Enum.map(list, &serialize_value/1)
+  end
+
+  defp serialize_value(%{__struct__: _} = struct) do
+    struct
+    |> Map.from_struct()
+    |> Map.new(fn {k, v} -> {to_string(k), serialize_value(v)} end)
+  end
+
+  defp serialize_value(map) when is_map(map) do
+    Map.new(map, fn {k, v} -> {to_string(k), serialize_value(v)} end)
+  end
+
+  defp serialize_value(atom) when is_atom(atom) and not is_nil(atom) and not is_boolean(atom) do
+    Atom.to_string(atom)
+  end
+
+  defp serialize_value(tuple) when is_tuple(tuple) do
+    tuple |> Tuple.to_list() |> Enum.map(&serialize_value/1)
+  end
+
+  defp serialize_value(other), do: other
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/live/run_detail_live.ex b/apps/gitlock_phx/lib/gitlock_phx_web/live/run_detail_live.ex
new file mode 100644
index 0000000..c68945d
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/live/run_detail_live.ex
@@ -0,0 +1,217 @@
+defmodule GitlockPhxWeb.RunDetailLive do
+  use GitlockPhxWeb, :live_view
+
+  alias GitlockPhx.Pipelines
+
+  @impl true
+  def mount(%{"id" => id}, _session, socket) do
+    run = Pipelines.get_run_with_pipeline!(id)
+    parsed = parse_stored_results(run.results)
+
+    {:ok,
+     assign(socket,
+       run: run,
+       parsed_results: parsed,
+       page_title: "Run — #{pipeline_name(run)}"
+     )}
+  rescue
+    Ecto.NoResultsError ->
+      {:ok,
+       socket
+       |> put_flash(:error, "Run not found")
+       |> push_navigate(to: ~p"/runs")}
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div class="run-detail-page">
+      <div class="run-detail-container">
+        <header class="run-detail-header">
+          <div>
+            <.link navigate={~p"/runs"} class="run-back">&larr; Run History</.link>
+            <h1>{pipeline_name(@run)}</h1>
+          </div>
+          <div class="run-detail-meta">
+            <span class={"run-status-label #{@run.status}"}>{@run.status}</span>
+            <span class="run-meta-item">{@run.repo_url}</span>
+            <span class="run-meta-item">{format_datetime(@run.started_at)}</span>
+            <%= if @run.completed_at do %>
+              <span class="run-meta-item">{format_duration(@run)}</span>
+            <% end %>
+          </div>
+        </header>
+
+        <%= if @run.error do %>
+          <div class="run-error-banner">
+            <strong>Error:</strong> {@run.error}
+          </div>
+        <% end %>
+
+        <%= if length(@parsed_results) > 0 do %>
+          <div class="analyze-results">
+            <%= for %{label: label, status: :ok, rows: rows, columns: cols} <- @parsed_results do %>
+              <div class="result-card">
+                <div class="result-card-header">
+                  <h3>{label}</h3>
+                  <span class="result-count">{length(rows)} row{if length(rows) != 1, do: "s"}</span>
+                </div>
+                <div class="result-table-wrap">
+                  <table class="result-table">
+                    <thead>
+                      <tr>
+                        <%= for col <- cols do %>
+                          <th>{format_column(col)}</th>
+                        <% end %>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      <%= for row <- Enum.take(rows, 50) do %>
+                        <tr>
+                          <%= for col <- cols do %>
+                            <td title={to_string(Map.get(row, col, ""))}>
+                              {format_cell(Map.get(row, col))}
+                            </td>
+                          <% end %>
+                        </tr>
+                      <% end %>
+                    </tbody>
+                  </table>
+                  <%= if length(rows) > 50 do %>
+                    <p class="result-truncated">Showing 50 of {length(rows)} rows</p>
+                  <% end %>
+                </div>
+              </div>
+            <% end %>
+
+            <%= for %{label: label, status: :error, error: reason} <- @parsed_results do %>
+              <div class="result-card error">
+                <h3>{label}</h3>
+                <pre class="result-error">{reason}</pre>
+              </div>
+            <% end %>
+          </div>
+        <% else %>
+          <div class="runs-empty">
+            <p>No result data stored for this run.</p>
+          </div>
+        <% end %>
+      </div>
+    </div>
+    """
+  end
+
+  # ── Parse stored results ─────────────────────────────────────
+
+  # Results from serialize_for_storage are maps like:
+  # %{"node_id" => %{"status" => "ok", "label" => "...", "data" => ...}}
+  defp parse_stored_results(nil), do: []
+  defp parse_stored_results(results) when results == %{}, do: []
+
+  defp parse_stored_results(results) when is_map(results) do
+    results
+    |> Enum.map(fn {_node_id, node_result} -> parse_node_result(node_result) end)
+    |> Enum.reject(&is_nil/1)
+    |> Enum.sort_by(& &1.label)
+  end
+
+  defp parse_node_result(%{"status" => "ok", "label" => label, "data" => data}) do
+    parse_data(label, data)
+  end
+
+  defp parse_node_result(%{"status" => "error", "error" => reason}) do
+    %{label: reason, status: :error, error: reason, rows: [], columns: []}
+  end
+
+  defp parse_node_result(_), do: nil
+
+  defp parse_data(label, data) when is_list(data) and length(data) > 0 do
+    rows = Enum.map(data, &stringify_keys/1)
+    cols = rows |> List.first() |> Map.keys() |> prioritize_columns()
+    %{label: label, status: :ok, rows: rows, columns: cols}
+  end
+
+  defp parse_data(label, data) when is_map(data) do
+    values = Map.values(data)
+
+    case values do
+      [list] when is_list(list) and length(list) > 0 ->
+        parse_data(label, list)
+
+      _ ->
+        rows =
+          Enum.map(data, fn {k, v} -> %{"field" => to_string(k), "value" => format_cell(v)} end)
+
+        %{label: label, status: :ok, rows: rows, columns: ["field", "value"]}
+    end
+  end
+
+  defp parse_data(label, data) when is_binary(data) do
+    case Jason.decode(data) do
+      {:ok, decoded} -> parse_data(label, decoded)
+      _ -> %{label: label, status: :ok, rows: [%{"output" => data}], columns: ["output"]}
+    end
+  end
+
+  defp parse_data(label, _data) do
+    %{label: label, status: :ok, rows: [], columns: []}
+  end
+
+  defp stringify_keys(map) when is_map(map) do
+    Map.new(map, fn {k, v} -> {to_string(k), v} end)
+  end
+
+  defp stringify_keys(other), do: %{"value" => inspect(other)}
+
+  # ── Shared helpers ───────────────────────────────────────────
+
+  defp pipeline_name(%{pipeline: %{name: name}}), do: name
+  defp pipeline_name(_), do: "Unknown Pipeline"
+
+  defp prioritize_columns(cols) do
+    priority =
+      ~w(file path name entity label author changes revisions complexity score risk normalized_score percentile)
+
+    {front, rest} =
+      Enum.split_with(cols, fn c -> String.downcase(c) in priority end)
+
+    sorted_front =
+      Enum.sort_by(front, fn c ->
+        Enum.find_index(priority, &(&1 == String.downcase(c))) || 999
+      end)
+
+    sorted_front ++ Enum.sort(rest)
+  end
+
+  defp format_column(col) do
+    col
+    |> String.replace("_", " ")
+    |> String.split(" ")
+    |> Enum.map(&String.capitalize/1)
+    |> Enum.join(" ")
+  end
+
+  defp format_cell(nil), do: "—"
+  defp format_cell(v) when is_float(v), do: :erlang.float_to_binary(v, decimals: 3)
+  defp format_cell(v) when is_integer(v), do: Integer.to_string(v)
+  defp format_cell(v) when is_binary(v), do: v
+  defp format_cell(v) when is_list(v), do: Enum.join(Enum.map(v, &to_string/1), ", ")
+  defp format_cell(v) when is_map(v), do: inspect(v, limit: 5)
+  defp format_cell(v), do: inspect(v)
+
+  defp format_datetime(nil), do: ""
+  defp format_datetime(dt), do: Calendar.strftime(dt, "%b %d, %Y at %H:%M UTC")
+
+  defp format_duration(%{started_at: nil}), do: ""
+  defp format_duration(%{completed_at: nil}), do: ""
+
+  defp format_duration(%{started_at: started, completed_at: completed}) do
+    diff = DateTime.diff(completed, started, :millisecond)
+
+    cond do
+      diff < 1_000 -> "#{diff}ms"
+      diff < 60_000 -> "#{Float.round(diff / 1_000, 1)}s"
+      true -> "#{div(diff, 60_000)}m #{rem(div(diff, 1_000), 60)}s"
+    end
+  end
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/live/runs_live.ex b/apps/gitlock_phx/lib/gitlock_phx_web/live/runs_live.ex
new file mode 100644
index 0000000..d43a693
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/live/runs_live.ex
@@ -0,0 +1,125 @@
+defmodule GitlockPhxWeb.RunsLive do
+  use GitlockPhxWeb, :live_view
+
+  alias GitlockPhx.Pipelines
+
+  @impl true
+  def mount(_params, _session, socket) do
+    user = current_user(socket)
+
+    runs = if user, do: Pipelines.list_runs_for_user(user.id), else: []
+
+    {:ok,
+     assign(socket,
+       runs: runs,
+       page_title: "Run History"
+     )}
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div class="runs-page">
+      <div class="runs-container">
+        <header class="runs-header">
+          <h1>Run History</h1>
+          <p class="runs-subtitle">Past pipeline executions and their results.</p>
+        </header>
+
+        <%= if current_user(assigns) do %>
+          <%= if length(@runs) > 0 do %>
+            <div class="runs-list">
+              <%= for run <- @runs do %>
+                <.link navigate={~p"/runs/#{run.id}"} class="run-row">
+                  <div class="run-row-main">
+                    <span class={"run-status-dot #{run.status}"}></span>
+                    <div class="run-info">
+                      <span class="run-pipeline-name">{pipeline_name(run)}</span>
+                      <span class="run-repo">{run.repo_url}</span>
+                    </div>
+                  </div>
+                  <div class="run-row-meta">
+                    <span class={"run-status-label #{run.status}"}>{run.status}</span>
+                    <span class="run-duration">{format_duration(run)}</span>
+                    <span class="run-time">{format_time(run.started_at || run.inserted_at)}</span>
+                  </div>
+                </.link>
+              <% end %>
+            </div>
+          <% else %>
+            <div class="runs-empty">
+              <p>No runs yet.</p>
+              <p>
+                <.link navigate={~p"/analyze"}>Run an analysis</.link>
+                or <.link navigate={~p"/workflows"}>execute a pipeline</.link>
+                to see results here.
+              </p>
+            </div>
+          <% end %>
+        <% else %>
+          <div class="runs-empty">
+            <p>
+              <.link navigate={~p"/users/log-in"}>Log in</.link> to see your run history.
+            </p>
+          </div>
+        <% end %>
+      </div>
+    </div>
+    """
+  end
+
+  @impl true
+  def handle_event("delete", %{"id" => id}, socket) do
+    user = current_user(socket)
+
+    if user do
+      run = Pipelines.get_run!(String.to_integer(id))
+
+      if run.user_id == user.id do
+        GitlockPhx.Repo.delete(run)
+        runs = Pipelines.list_runs_for_user(user.id)
+        {:noreply, socket |> assign(runs: runs) |> put_flash(:info, "Run deleted")}
+      else
+        {:noreply, put_flash(socket, :error, "Not authorized")}
+      end
+    else
+      {:noreply, put_flash(socket, :error, "Log in to manage runs")}
+    end
+  end
+
+  # ── Helpers ──────────────────────────────────────────────────
+
+  defp current_user(%{assigns: %{current_scope: %{user: %{id: _} = user}}}), do: user
+  defp current_user(_), do: nil
+
+  defp pipeline_name(%{pipeline: %{name: name}}), do: name
+  defp pipeline_name(_), do: "Unknown Pipeline"
+
+  defp format_duration(%{started_at: nil}), do: ""
+  defp format_duration(%{completed_at: nil}), do: "running..."
+
+  defp format_duration(%{started_at: started, completed_at: completed}) do
+    diff = DateTime.diff(completed, started, :millisecond)
+
+    cond do
+      diff < 1_000 -> "#{diff}ms"
+      diff < 60_000 -> "#{Float.round(diff / 1_000, 1)}s"
+      true -> "#{div(diff, 60_000)}m #{rem(div(diff, 1_000), 60)}s"
+    end
+  end
+
+  defp format_time(nil), do: ""
+
+  defp format_time(dt) do
+    now = DateTime.utc_now()
+    diff = DateTime.diff(now, dt, :second)
+
+    cond do
+      diff < 60 -> "just now"
+      diff < 3600 -> "#{div(diff, 60)}m ago"
+      diff < 86400 -> "#{div(diff, 3600)}h ago"
+      diff < 604_800 -> "#{div(diff, 86400)}d ago"
+      true -> Calendar.strftime(dt, "%b %d, %Y %H:%M")
+    end
+  end
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/live/workflow_live.ex b/apps/gitlock_phx/lib/gitlock_phx_web/live/workflow_live.ex
new file mode 100644
index 0000000..9182cd6
--- /dev/null
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/live/workflow_live.ex
@@ -0,0 +1,660 @@
+defmodule GitlockPhxWeb.WorkflowLive do
+  use GitlockPhxWeb, :live_view
+
+  alias GitlockWorkflows.{Pipeline, Node, Edge, Serializer, Executor}
+  alias GitlockPhx.Pipelines
+  alias GitlockPhxWeb.ResultSerializer
+
+  require Logger
+
+  @impl true
+  def mount(params, _session, socket) do
+    templates = Pipelines.list_templates()
+    user = current_user(socket)
+
+    {pipeline, saved_id} = load_initial_pipeline(params, user)
+
+    my_pipelines =
+      if user, do: Pipelines.list_pipelines(user.id), else: []
+
+    {:ok,
+     assign(socket,
+       pipeline: pipeline,
+       saved_pipeline_id: saved_id,
+       dirty: false,
+       templates: templates,
+       my_pipelines: my_pipelines,
+       validation: :ok,
+       execution: :idle,
+       node_progress: %{},
+       results: nil,
+       current_run: nil,
+       show_save_dialog: false,
+       save_name: pipeline.name,
+       page_title: pipeline.name
+     )}
+  end
+
+  @impl true
+  def handle_params(params, _uri, socket) do
+    user = current_user(socket)
+
+    case params do
+      %{"id" => id} ->
+        case load_saved_pipeline(id, user) do
+          {:ok, pipeline, saved_id} ->
+            {:noreply,
+             socket
+             |> assign(
+               pipeline: pipeline,
+               saved_pipeline_id: saved_id,
+               dirty: false,
+               save_name: pipeline.name,
+               page_title: pipeline.name
+             )
+             |> push_pipeline_state()}
+
+          :error ->
+            {:noreply,
+             socket
+             |> put_flash(:error, "Pipeline not found")
+             |> push_navigate(to: ~p"/workflows")}
+        end
+
+      _ ->
+        {:noreply, socket}
+    end
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div class="workflow-page">
+      <header class="workflow-header">
+        <div class="workflow-title-group">
+          <h1
+            contenteditable="true"
+            phx-blur="rename"
+            phx-hook="ContentEditable"
+            id="pipeline-name"
+            spellcheck="false"
+          >{@pipeline.name}</h1>
+          <%= if @dirty do %>
+            <span class="dirty-badge">Unsaved</span>
+          <% end %>
+          <%= if @saved_pipeline_id do %>
+            <span class="saved-badge">Saved</span>
+          <% end %>
+        </div>
+
+        <div class="workflow-actions">
+          <form phx-change="load_template" class="template-dropdown">
+            <select name="template_id" class="template-select">
+              <option value="">Load template</option>
+              <optgroup label="Templates">
+                <%= for tpl <- @templates do %>
+                  <option value={"tpl:#{tpl.id}"}>{tpl.name}</option>
+                <% end %>
+              </optgroup>
+              <%= if length(@my_pipelines) > 0 do %>
+                <optgroup label="My Pipelines">
+                  <%= for p <- @my_pipelines do %>
+                    <option value={"saved:#{p.id}"}>{p.name}</option>
+                  <% end %>
+                </optgroup>
+              <% end %>
+            </select>
+          </form>
+
+          <span class={["validation-badge", validation_class(@validation)]}>
+            {validation_label(@validation)}
+          </span>
+          <button phx-click="validate" class="btn btn-secondary">Validate</button>
+
+          <%= if current_user(assigns) do %>
+            <button phx-click="save" class="btn btn-secondary">
+              {if @saved_pipeline_id, do: "Save", else: "Save As"}
+            </button>
+          <% end %>
+
+          <button
+            phx-click="execute"
+            class={["btn btn-execute", execution_class(@execution)]}
+            disabled={@execution == :running}
+          >
+            {execution_label(@execution)}
+          </button>
+        </div>
+      </header>
+
+      <%= if @show_save_dialog do %>
+        <div class="save-dialog-overlay" phx-click="cancel_save">
+          <div class="save-dialog" phx-click-away="cancel_save">
+            <h3>Save Pipeline</h3>
+            <form phx-submit="confirm_save">
+              <div class="save-field">
+                <label for="save-name">Name</label>
+                <input
+                  type="text"
+                  id="save-name"
+                  name="name"
+                  value={@save_name}
+                  autofocus
+                  class="save-input"
+                  phx-debounce="100"
+                />
+              </div>
+              <div class="save-actions">
+                <button type="button" phx-click="cancel_save" class="btn btn-secondary">
+                  Cancel
+                </button>
+                <button type="submit" class="btn btn-execute">Save</button>
+              </div>
+            </form>
+          </div>
+        </div>
+      <% end %>
+
+      <div id="workflow-canvas" phx-hook="WorkflowCanvas" phx-update="ignore" class="workflow-canvas">
+        <!-- Svelte mounts here -->
+      </div>
+    </div>
+    """
+  end
+
+  # ── Events ───────────────────────────────────────────────────
+
+  @impl true
+  def handle_event("request_state", _params, socket) do
+    socket =
+      socket
+      |> push_pipeline_state()
+      |> push_catalog()
+
+    {:noreply, socket}
+  end
+
+  def handle_event("load_template", %{"template_id" => ""}, socket), do: {:noreply, socket}
+
+  def handle_event("load_template", %{"template_id" => "tpl:" <> id}, socket) do
+    template = Pipelines.get_pipeline!(String.to_integer(id))
+    pipeline = Pipelines.to_workflow(template)
+
+    {:noreply,
+     socket
+     |> assign(
+       pipeline: pipeline,
+       saved_pipeline_id: nil,
+       dirty: false,
+       validation: :ok,
+       execution: :idle,
+       results: nil,
+       node_progress: %{},
+       save_name: pipeline.name,
+       page_title: pipeline.name
+     )
+     |> push_pipeline_state()}
+  end
+
+  def handle_event("load_template", %{"template_id" => "saved:" <> id}, socket) do
+    {:noreply, push_navigate(socket, to: ~p"/workflows/#{id}")}
+  end
+
+  # Back-compat for old format
+  def handle_event("load_template", %{"template_id" => id}, socket) do
+    template = Pipelines.get_pipeline!(String.to_integer(id))
+    pipeline = Pipelines.to_workflow(template)
+
+    {:noreply,
+     socket
+     |> assign(
+       pipeline: pipeline,
+       saved_pipeline_id: nil,
+       dirty: false,
+       validation: :ok,
+       execution: :idle,
+       results: nil,
+       node_progress: %{},
+       save_name: pipeline.name
+     )
+     |> push_pipeline_state()}
+  end
+
+  def handle_event("rename", %{"value" => name}, socket) do
+    name = String.trim(name)
+    name = if name == "", do: "Untitled Pipeline", else: name
+    pipeline = %{socket.assigns.pipeline | name: name}
+
+    {:noreply, assign(socket, pipeline: pipeline, save_name: name, dirty: true, page_title: name)}
+  end
+
+  def handle_event("add_node", %{"type_id" => type_id, "position" => pos}, socket) do
+    type_atom = String.to_existing_atom(type_id)
+    position = {pos["x"], pos["y"]}
+
+    case Node.new(type_atom, position: position) do
+      {:error, _} ->
+        {:noreply, put_flash(socket, :error, "Unknown node type: #{type_id}")}
+
+      node ->
+        case Pipeline.add_node(socket.assigns.pipeline, node) do
+          {:error, reason} ->
+            {:noreply, put_flash(socket, :error, "Cannot add node: #{reason}")}
+
+          pipeline ->
+            {:noreply,
+             socket
+             |> assign(pipeline: pipeline, execution: :idle, results: nil, dirty: true)
+             |> push_pipeline_state()}
+        end
+    end
+  end
+
+  def handle_event("connect", params, socket) do
+    edge =
+      Edge.new(
+        params["source_node_id"],
+        params["source_port_id"],
+        params["target_node_id"],
+        params["target_port_id"]
+      )
+
+    case Pipeline.add_edge(socket.assigns.pipeline, edge) do
+      {:error, reason} ->
+        {:noreply, put_flash(socket, :error, "Cannot connect: #{reason}")}
+
+      pipeline ->
+        {:noreply, socket |> assign(pipeline: pipeline, dirty: true) |> push_pipeline_state()}
+    end
+  end
+
+  def handle_event("node_moved", %{"node_id" => node_id, "position" => pos}, socket) do
+    pipeline = socket.assigns.pipeline
+    position = {pos["x"], pos["y"]}
+
+    case Map.fetch(pipeline.nodes, node_id) do
+      {:ok, node} ->
+        updated_node = %{node | position: position}
+        updated_nodes = Map.put(pipeline.nodes, node_id, updated_node)
+        pipeline = %{pipeline | nodes: updated_nodes}
+        {:noreply, assign(socket, pipeline: pipeline, dirty: true)}
+
+      :error ->
+        {:noreply, socket}
+    end
+  end
+
+  def handle_event("update_node_config", %{"node_id" => node_id, "config" => config}, socket) do
+    pipeline = socket.assigns.pipeline
+
+    case Map.fetch(pipeline.nodes, node_id) do
+      {:ok, node} ->
+        merged_config = Map.merge(node.config, normalize_config(config))
+        updated_node = %{node | config: merged_config}
+        updated_nodes = Map.put(pipeline.nodes, node_id, updated_node)
+        pipeline = %{pipeline | nodes: updated_nodes}
+        {:noreply, assign(socket, pipeline: pipeline, dirty: true)}
+
+      :error ->
+        {:noreply, socket}
+    end
+  end
+
+  def handle_event("delete_elements", %{"nodes" => node_ids, "edges" => edge_ids}, socket) do
+    pipeline =
+      socket.assigns.pipeline
+      |> remove_edges(edge_ids)
+      |> remove_nodes(node_ids)
+
+    {:noreply, socket |> assign(pipeline: pipeline, dirty: true) |> push_pipeline_state()}
+  end
+
+  def handle_event("validate", _params, socket) do
+    validation = Pipeline.validate(socket.assigns.pipeline)
+    {:noreply, assign(socket, validation: validation)}
+  end
+
+  def handle_event("save", _params, socket) do
+    user = current_user(socket)
+
+    cond do
+      is_nil(user) ->
+        {:noreply, put_flash(socket, :error, "Log in to save pipelines")}
+
+      socket.assigns.saved_pipeline_id ->
+        # Update existing
+        do_update_pipeline(socket, user)
+
+      true ->
+        # Show save-as dialog
+        {:noreply,
+         assign(socket, show_save_dialog: true, save_name: socket.assigns.pipeline.name)}
+    end
+  end
+
+  def handle_event("confirm_save", %{"name" => name}, socket) do
+    user = current_user(socket)
+    name = String.trim(name)
+    name = if name == "", do: "Untitled Pipeline", else: name
+
+    pipeline = %{socket.assigns.pipeline | name: name}
+
+    case Pipelines.save_pipeline(user.id, pipeline) do
+      {:ok, saved} ->
+        my_pipelines = Pipelines.list_pipelines(user.id)
+
+        {:noreply,
+         socket
+         |> assign(
+           pipeline: pipeline,
+           saved_pipeline_id: saved.id,
+           dirty: false,
+           show_save_dialog: false,
+           my_pipelines: my_pipelines,
+           save_name: name,
+           page_title: name
+         )
+         |> put_flash(:info, "Pipeline saved")
+         |> push_patch(to: ~p"/workflows/#{saved.id}")}
+
+      {:error, changeset} ->
+        {:noreply,
+         socket
+         |> assign(show_save_dialog: false)
+         |> put_flash(:error, "Save failed: #{inspect_errors(changeset)}")}
+    end
+  end
+
+  def handle_event("cancel_save", _params, socket) do
+    {:noreply, assign(socket, show_save_dialog: false)}
+  end
+
+  def handle_event("execute", _params, socket) do
+    pipeline = socket.assigns.pipeline
+
+    repo_url = find_repo_url(pipeline)
+
+    cond do
+      repo_url == nil or repo_url == "" ->
+        {:noreply, put_flash(socket, :error, "Configure a Repository URL on the Git Log node")}
+
+      match?({:error, _}, Pipeline.validate(pipeline)) ->
+        validation = Pipeline.validate(pipeline)
+
+        error_details =
+          case validation do
+            {:error, errors} ->
+              errors
+              |> Enum.map(fn {_key, msg} -> msg end)
+              |> Enum.join("; ")
+
+            _ ->
+              "Unknown validation error"
+          end
+
+        {:noreply,
+         socket
+         |> assign(validation: validation)
+         |> put_flash(:error, "Validation failed: #{error_details}")}
+
+      true ->
+        user = current_user(socket)
+        {socket, run} = maybe_create_run(socket, user, pipeline, repo_url)
+
+        Executor.run(pipeline, repo_url, self(), %{format: "json"})
+
+        {:noreply,
+         socket
+         |> assign(
+           validation: :ok,
+           execution: :running,
+           node_progress: %{},
+           results: nil,
+           current_run: run
+         )
+         |> push_event("execution_started", %{})}
+    end
+  end
+
+  # ── Async execution messages ─────────────────────────────────
+
+  @impl true
+  def handle_info({:pipeline_progress, node_id, :running}, socket) do
+    progress = Map.put(socket.assigns.node_progress, node_id, :running)
+
+    {:noreply,
+     socket
+     |> assign(node_progress: progress)
+     |> push_event("node_progress", %{node_id: node_id, status: "running"})}
+  end
+
+  def handle_info({:pipeline_progress, node_id, {:status, message}}, socket) do
+    {:noreply,
+     push_event(socket, "node_progress", %{
+       node_id: node_id,
+       status: "running",
+       status_text: message
+     })}
+  end
+
+  def handle_info({:pipeline_progress, node_id, {:done, result}}, socket) do
+    progress = Map.put(socket.assigns.node_progress, node_id, :done)
+    serialized = ResultSerializer.serialize(result)
+    results = Map.put(socket.assigns.results || %{}, node_id, serialized)
+
+    {:noreply,
+     socket
+     |> assign(node_progress: progress, results: results)
+     |> push_event("node_progress", %{node_id: node_id, status: "done", result: serialized})}
+  end
+
+  def handle_info({:pipeline_progress, node_id, {:error, reason}}, socket) do
+    progress = Map.put(socket.assigns.node_progress, node_id, {:error, reason})
+
+    {:noreply,
+     socket
+     |> assign(node_progress: progress)
+     |> push_event("node_progress", %{
+       node_id: node_id,
+       status: "error",
+       error: inspect(reason)
+     })}
+  end
+
+  def handle_info({:pipeline_complete, results}, socket) do
+    {successes, failures} =
+      results
+      |> Map.values()
+      |> Enum.split_with(fn
+        {:ok, _} -> true
+        _ -> false
+      end)
+
+    {level, message} =
+      case {length(successes), length(failures)} do
+        {s, 0} -> {:info, "Pipeline complete — #{s} step(s) succeeded"}
+        {0, f} -> {:error, "Pipeline failed — #{f} step(s) failed"}
+        {s, f} -> {:warning, "Pipeline done — #{s} succeeded, #{f} failed"}
+      end
+
+    serialized_results = ResultSerializer.serialize_results(results)
+
+    # Persist run results
+    persist_run_results(socket.assigns[:current_run], results, failures)
+
+    {:noreply,
+     socket
+     |> assign(execution: :done, results: serialized_results, current_run: nil)
+     |> put_flash(level, message)}
+  end
+
+  # ── Run persistence helpers ──────────────────────────────────
+
+  defp maybe_create_run(socket, nil, _pipeline, _repo_url), do: {socket, nil}
+
+  defp maybe_create_run(socket, user, pipeline, repo_url) do
+    {socket, pipeline_id} = ensure_saved(socket, user, pipeline)
+
+    if pipeline_id do
+      case Pipelines.create_run(pipeline_id, user.id, repo_url) do
+        {:ok, run} -> {socket, run}
+        {:error, _} -> {socket, nil}
+      end
+    else
+      {socket, nil}
+    end
+  end
+
+  defp ensure_saved(socket, user, pipeline) do
+    case socket.assigns.saved_pipeline_id do
+      nil ->
+        case Pipelines.save_pipeline(user.id, pipeline) do
+          {:ok, saved} ->
+            my_pipelines = Pipelines.list_pipelines(user.id)
+
+            socket =
+              assign(socket,
+                saved_pipeline_id: saved.id,
+                dirty: false,
+                my_pipelines: my_pipelines
+              )
+
+            {socket, saved.id}
+
+          {:error, _} ->
+            {socket, nil}
+        end
+
+      id ->
+        if socket.assigns.dirty do
+          saved = Pipelines.get_pipeline!(id)
+          Pipelines.update_pipeline(saved, pipeline)
+          {assign(socket, dirty: false), id}
+        else
+          {socket, id}
+        end
+    end
+  end
+
+  defp persist_run_results(nil, _results, _failures), do: :ok
+
+  defp persist_run_results(run, results, failures) do
+    storable = ResultSerializer.serialize_for_storage(results)
+
+    {status, error} =
+      case failures do
+        [] ->
+          {"completed", nil}
+
+        _ ->
+          error_msg =
+            failures
+            |> Enum.map(fn {:error, r} -> inspect(r) end)
+            |> Enum.join("; ")
+
+          {"failed", error_msg}
+      end
+
+    Pipelines.finish_run(run, status, storable, error)
+  end
+
+  # ── Private helpers ──────────────────────────────────────────
+
+  defp current_user(%{assigns: %{current_scope: %{user: %{id: _} = user}}}), do: user
+  defp current_user(_), do: nil
+
+  defp load_initial_pipeline(%{"id" => id}, user) do
+    case load_saved_pipeline(id, user) do
+      {:ok, pipeline, saved_id} -> {pipeline, saved_id}
+      :error -> {Pipeline.new("New Pipeline"), nil}
+    end
+  end
+
+  defp load_initial_pipeline(_params, _user) do
+    {Pipeline.new("New Pipeline"), nil}
+  end
+
+  defp load_saved_pipeline(id, _user) do
+    saved = Pipelines.get_pipeline!(String.to_integer(id))
+    pipeline = Pipelines.to_workflow(saved)
+
+    if saved.is_template do
+      # Templates load as a new unsaved copy
+      {:ok, pipeline, nil}
+    else
+      {:ok, pipeline, saved.id}
+    end
+  rescue
+    Ecto.NoResultsError -> :error
+  end
+
+  defp do_update_pipeline(socket, _user) do
+    saved = Pipelines.get_pipeline!(socket.assigns.saved_pipeline_id)
+
+    case Pipelines.update_pipeline(saved, socket.assigns.pipeline) do
+      {:ok, _saved} ->
+        {:noreply,
+         socket
+         |> assign(dirty: false)
+         |> put_flash(:info, "Pipeline saved")}
+
+      {:error, changeset} ->
+        {:noreply, put_flash(socket, :error, "Save failed: #{inspect_errors(changeset)}")}
+    end
+  end
+
+  defp find_repo_url(%Pipeline{nodes: nodes}) do
+    nodes
+    |> Map.values()
+    |> Enum.find(&(&1.type == :git_log))
+    |> case do
+      nil -> nil
+      node -> Map.get(node.config, "repo_url") || Map.get(node.config, :repo_url)
+    end
+  end
+
+  defp normalize_config(config) when is_map(config) do
+    Map.new(config, fn
+      {k, v} when is_binary(v) and byte_size(v) == 0 -> {k, nil}
+      {k, v} -> {k, v}
+    end)
+  end
+
+  defp push_pipeline_state(socket) do
+    push_event(socket, "pipeline_state", %{
+      pipeline: Serializer.to_map(socket.assigns.pipeline)
+    })
+  end
+
+  defp push_catalog(socket) do
+    push_event(socket, "catalog", %{catalog: Serializer.catalog_to_list()})
+  end
+
+  defp remove_nodes(pipeline, node_ids) do
+    Enum.reduce(node_ids, pipeline, &Pipeline.remove_node(&2, &1))
+  end
+
+  defp remove_edges(pipeline, edge_ids) do
+    Enum.reduce(edge_ids, pipeline, &Pipeline.remove_edge(&2, &1))
+  end
+
+  defp inspect_errors(%Ecto.Changeset{} = cs) do
+    Ecto.Changeset.traverse_errors(cs, fn {msg, _opts} -> msg end) |> inspect()
+  end
+
+  defp inspect_errors(other), do: inspect(other)
+
+  defp validation_class(:ok), do: "valid"
+  defp validation_class({:error, _}), do: "invalid"
+
+  defp validation_label(:ok), do: "Valid"
+  defp validation_label({:error, errors}), do: "#{length(errors)} issue(s)"
+
+  defp execution_class(:idle), do: ""
+  defp execution_class(:running), do: "running"
+  defp execution_class(:done), do: "done"
+
+  defp execution_label(:idle), do: "Execute"
+  defp execution_label(:running), do: "Running..."
+  defp execution_label(:done), do: "Done"
+end
diff --git a/apps/gitlock_phx/lib/gitlock_phx_web/router.ex b/apps/gitlock_phx/lib/gitlock_phx_web/router.ex
index f0fe438..1060c9b 100644
--- a/apps/gitlock_phx/lib/gitlock_phx_web/router.ex
+++ b/apps/gitlock_phx/lib/gitlock_phx_web/router.ex
@@ -24,6 +24,20 @@ defmodule GitlockPhxWeb.Router do
     get "/app", PageController, :home
   end
 
+  scope "/", GitlockPhxWeb do
+    pipe_through [:browser]
+
+    live_session :app,
+      on_mount: [{GitlockPhxWeb.UserAuth, :mount_current_scope}] do
+      live "/analyze", AnalyzeLive
+      live "/workflows", WorkflowLive
+      live "/workflows/:id", WorkflowLive
+      live "/pipelines", PipelinesLive
+      live "/runs", RunsLive
+      live "/runs/:id", RunDetailLive
+    end
+  end
+
   # Other scopes may use custom stacks.
   # scope "/api", GitlockPhxWeb do
   #   pipe_through :api
diff --git a/apps/gitlock_phx/mix.exs b/apps/gitlock_phx/mix.exs
index 8629303..8e0d1b6 100644
--- a/apps/gitlock_phx/mix.exs
+++ b/apps/gitlock_phx/mix.exs
@@ -40,6 +40,7 @@ defmodule GitlockPhx.MixProject do
       {:tidewave, "~> 0.1", only: :dev},
       {:bcrypt_elixir, "~> 3.0"},
       {:gitlock_core, in_umbrella: true},
+      {:gitlock_workflows, in_umbrella: true},
       {:phoenix, "~> 1.8.0-rc.3", override: true},
       {:phoenix_ecto, "~> 4.5"},
       {:ecto_sql, "~> 3.10"},
@@ -81,11 +82,11 @@ defmodule GitlockPhx.MixProject do
       "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
       "ecto.reset": ["ecto.drop", "ecto.setup"],
       test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"],
-      "assets.setup": ["tailwind.install --if-missing", "esbuild.install --if-missing"],
-      "assets.build": ["tailwind gitlock_phx", "esbuild gitlock_phx"],
+      "assets.setup": ["tailwind.install --if-missing", "cmd --cd assets npm install"],
+      "assets.build": ["tailwind gitlock_phx", "cmd --cd assets node build.mjs"],
       "assets.deploy": [
         "tailwind gitlock_phx --minify",
-        "esbuild gitlock_phx --minify",
+        "cmd --cd assets node build.mjs --deploy",
         "phx.digest"
       ]
     ]
diff --git a/apps/gitlock_phx/priv/repo/migrations/20260221112426_create_pipelines_and_runs.exs b/apps/gitlock_phx/priv/repo/migrations/20260221112426_create_pipelines_and_runs.exs
new file mode 100644
index 0000000..e424277
--- /dev/null
+++ b/apps/gitlock_phx/priv/repo/migrations/20260221112426_create_pipelines_and_runs.exs
@@ -0,0 +1,35 @@
+defmodule GitlockPhx.Repo.Migrations.CreatePipelinesAndRuns do
+  use Ecto.Migration
+
+  def change do
+    create table(:pipelines) do
+      add :user_id, references(:users, on_delete: :delete_all)
+      add :name, :string, null: false
+      add :description, :text, default: ""
+      add :config, :map, null: false, default: %{}
+      add :is_template, :boolean, default: false
+
+      timestamps(type: :utc_datetime)
+    end
+
+    create index(:pipelines, [:user_id])
+    create index(:pipelines, [:is_template])
+
+    create table(:pipeline_runs) do
+      add :pipeline_id, references(:pipelines, on_delete: :delete_all), null: false
+      add :user_id, references(:users, on_delete: :delete_all), null: false
+      add :repo_url, :string, null: false
+      add :status, :string, null: false, default: "running"
+      add :results, :map, default: %{}
+      add :error, :text
+      add :started_at, :utc_datetime
+      add :completed_at, :utc_datetime
+
+      timestamps(type: :utc_datetime)
+    end
+
+    create index(:pipeline_runs, [:pipeline_id])
+    create index(:pipeline_runs, [:user_id])
+    create index(:pipeline_runs, [:status])
+  end
+end
diff --git a/apps/gitlock_phx/priv/repo/seeds.exs b/apps/gitlock_phx/priv/repo/seeds.exs
index 8c1b48a..2942652 100644
--- a/apps/gitlock_phx/priv/repo/seeds.exs
+++ b/apps/gitlock_phx/priv/repo/seeds.exs
@@ -1,11 +1,6 @@
 # Script for populating the database. You can run it as:
 #
 #     mix run priv/repo/seeds.exs
-#
-# Inside the script, you can read and write to any of your
-# repositories directly:
-#
-#     GitlockPhx.Repo.insert!(%GitlockPhx.SomeSchema{})
-#
-# We recommend using the bang functions (`insert!`, `update!`
-# and so on) as they will fail if something goes wrong.
+
+# Seed pipeline templates
+GitlockPhx.Pipelines.seed_templates!()
diff --git a/apps/gitlock_workflows/.formatter.exs b/apps/gitlock_workflows/.formatter.exs
new file mode 100644
index 0000000..d304ff3
--- /dev/null
+++ b/apps/gitlock_workflows/.formatter.exs
@@ -0,0 +1,3 @@
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows.ex b/apps/gitlock_workflows/lib/gitlock_workflows.ex
new file mode 100644
index 0000000..524a090
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows.ex
@@ -0,0 +1,8 @@
+defmodule GitlockWorkflows do
+  @moduledoc """
+  Visual workflow builder for Gitlock analysis pipelines.
+
+  Provides a domain model for constructing directed acyclic graphs
+  of analysis steps that compile down to executable Reactor workflows.
+  """
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/application.ex b/apps/gitlock_workflows/lib/gitlock_workflows/application.ex
new file mode 100644
index 0000000..bc46b9c
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/application.ex
@@ -0,0 +1,19 @@
+defmodule GitlockWorkflows.Application do
+  @moduledoc false
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      GitlockWorkflows.RuntimeSupervisor
+    ]
+
+    opts = [strategy: :one_for_one, name: GitlockWorkflows.Supervisor]
+
+    with {:ok, pid} <- Supervisor.start_link(children, opts) do
+      # Register built-in runtime nodes after supervisor is up
+      GitlockWorkflows.Runtime.Registry.register_builtin_nodes()
+      {:ok, pid}
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/compiler.ex b/apps/gitlock_workflows/lib/gitlock_workflows/compiler.ex
new file mode 100644
index 0000000..a4f6248
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/compiler.ex
@@ -0,0 +1,184 @@
+defmodule GitlockWorkflows.Compiler do
+  @moduledoc """
+  Compiles a visual Pipeline into an executable Runtime.Workflow.
+
+  The Pipeline model (Node, Edge, Port) serves the SvelteFlow UI and DB persistence.
+  The Runtime.Workflow model serves execution via Reactor. This module bridges them.
+
+  Node type mapping is derived from `NodeCatalog.runtime_type/1` — there is no
+  separate mapping table. Adding a new node type to the catalog with a `runtime_module`
+  automatically makes it compilable.
+  """
+
+  alias GitlockWorkflows.{Pipeline, NodeCatalog}
+  alias GitlockWorkflows.Runtime.Workflow
+
+  require Logger
+
+  @doc """
+  Compiles a Pipeline into a Reactor-ready Workflow.
+
+  ## Options
+
+    * `:repo_path` - Repository path injected into trigger node parameters
+  """
+  @spec compile(Pipeline.t(), keyword()) :: {:ok, Workflow.t()} | {:error, term()}
+  def compile(%Pipeline{} = pipeline, opts \\ []) do
+    with {:ok, workflow} <- to_workflow(pipeline, opts),
+         {:ok, compiled} <- Workflow.to_reactor(workflow) do
+      {:ok, compiled}
+    end
+  end
+
+  @doc "Converts a Pipeline to a Runtime.Workflow without compiling to Reactor."
+  @spec to_workflow(Pipeline.t(), keyword()) :: {:ok, Workflow.t()} | {:error, term()}
+  def to_workflow(%Pipeline{} = pipeline, opts \\ []) do
+    repo_path = Keyword.get(opts, :repo_path)
+    nodes = compile_nodes(pipeline, repo_path)
+    compiled_node_ids = MapSet.new(nodes, & &1.id)
+    connections = compile_connections(pipeline, compiled_node_ids)
+
+    workflow = %Workflow{
+      id: pipeline.id,
+      name: pipeline.name,
+      description: pipeline.description,
+      nodes: nodes,
+      connections: connections,
+      settings: %{},
+      repo_path: repo_path,
+      version: 1
+    }
+
+    {:ok, workflow}
+  rescue
+    e -> {:error, {:compilation_error, Exception.message(e)}}
+  end
+
+  @doc """
+  Returns the Runtime Registry node type string for a NodeCatalog type atom.
+
+  Delegates to `NodeCatalog.runtime_type/1`.
+  """
+  @spec runtime_type(atom()) :: String.t() | nil
+  def runtime_type(catalog_type), do: NodeCatalog.runtime_type(catalog_type)
+
+  # ── Private ──────────────────────────────────────────────────
+
+  defp compile_nodes(%Pipeline{nodes: nodes}, repo_path) do
+    nodes
+    |> Map.values()
+    |> Enum.map(&compile_node(&1, repo_path))
+    |> Enum.reject(&is_nil/1)
+  end
+
+  defp compile_node(node, repo_path) do
+    case NodeCatalog.runtime_type(node.type) do
+      nil ->
+        Logger.debug("Skipping node #{node.id} (#{node.type}): no runtime module")
+        nil
+
+      runtime_type ->
+        {x, y} = node.position
+        params = build_parameters(node, runtime_type, repo_path)
+
+        %{
+          id: node.id,
+          type: runtime_type,
+          position: [x, y],
+          parameters: params,
+          disabled: false
+        }
+    end
+  end
+
+  defp build_parameters(node, "gitlock.trigger.git_commits", repo_path) do
+    params = node.config || %{}
+
+    params =
+      if repo_path do
+        Map.put(params, "repo_path", repo_path)
+      else
+        url = Map.get(params, "repo_url") || Map.get(params, :repo_url)
+        if url, do: Map.put(params, "repo_path", url), else: params
+      end
+
+    # Build git_options from config fields for the runtime node
+    git_options =
+      %{}
+      |> maybe_put_option(:since, params, "since")
+      |> maybe_put_option(:until, params, "until")
+      |> maybe_put_option(:max_count, params, "depth")
+      |> maybe_put_option(:path, params, "path_filter")
+
+    branch = get_nonempty(params, "branch")
+
+    params
+    |> Map.put("git_options", git_options)
+    |> then(fn p -> if branch, do: Map.put(p, "branch", branch), else: p end)
+  end
+
+  defp maybe_put_option(opts, _key, params, config_key) do
+    case get_nonempty(params, config_key) do
+      nil -> opts
+      value -> Map.put(opts, config_key, value)
+    end
+  end
+
+  defp get_nonempty(params, key) do
+    value = Map.get(params, key) || Map.get(params, String.to_atom(key))
+
+    case value do
+      nil -> nil
+      "" -> nil
+      v when is_integer(v) and v > 0 -> v
+      v when is_binary(v) -> v
+      _ -> nil
+    end
+  end
+
+  # Complexity trend analysis needs repo_path for `git show` on historical files
+  defp build_parameters(node, "gitlock.analysis.complexity_trend", repo_path) do
+    params = node.config || %{}
+    if repo_path, do: Map.put(params, "repo_path", repo_path), else: params
+  end
+
+  defp build_parameters(node, _runtime_type, _repo_path) do
+    node.config || %{}
+  end
+
+  defp compile_connections(%Pipeline{nodes: nodes, edges: edges}, compiled_node_ids) do
+    port_name_lookup = build_port_name_lookup(nodes)
+
+    edges
+    |> Map.values()
+    |> Enum.map(&compile_edge(&1, port_name_lookup, compiled_node_ids))
+    |> Enum.reject(&is_nil/1)
+  end
+
+  defp compile_edge(edge, port_name_lookup, compiled_node_ids) do
+    with true <- MapSet.member?(compiled_node_ids, edge.source_node_id),
+         true <- MapSet.member?(compiled_node_ids, edge.target_node_id),
+         {:ok, src_port_name} <- Map.fetch(port_name_lookup, edge.source_port_id),
+         {:ok, tgt_port_name} <- Map.fetch(port_name_lookup, edge.target_port_id) do
+      %{
+        from: %{node: edge.source_node_id, port: src_port_name},
+        to: %{node: edge.target_node_id, port: tgt_port_name}
+      }
+    else
+      _ ->
+        Logger.debug("Skipping edge #{edge.id}: endpoint not in compiled set")
+        nil
+    end
+  end
+
+  defp build_port_name_lookup(nodes) do
+    nodes
+    |> Map.values()
+    |> Enum.flat_map(fn node ->
+      Enum.map(node.input_ports ++ node.output_ports, fn port ->
+        {port.id, port.name}
+      end)
+    end)
+    |> Map.new()
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/edge.ex b/apps/gitlock_workflows/lib/gitlock_workflows/edge.ex
new file mode 100644
index 0000000..693b578
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/edge.ex
@@ -0,0 +1,33 @@
+defmodule GitlockWorkflows.Edge do
+  @moduledoc """
+  A directed connection between an output port of one node
+  and an input port of another node.
+  """
+
+  @type t :: %__MODULE__{
+          id: String.t(),
+          source_node_id: String.t(),
+          source_port_id: String.t(),
+          target_node_id: String.t(),
+          target_port_id: String.t()
+        }
+
+  @enforce_keys [:id, :source_node_id, :source_port_id, :target_node_id, :target_port_id]
+  defstruct [:id, :source_node_id, :source_port_id, :target_node_id, :target_port_id]
+
+  @doc """
+  Creates a new edge connecting a source output port to a target input port.
+  """
+  @spec new(String.t(), String.t(), String.t(), String.t()) :: t()
+  def new(source_node_id, source_port_id, target_node_id, target_port_id) do
+    %__MODULE__{
+      id: gen_id(),
+      source_node_id: source_node_id,
+      source_port_id: source_port_id,
+      target_node_id: target_node_id,
+      target_port_id: target_port_id
+    }
+  end
+
+  defp gen_id, do: :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/executor.ex b/apps/gitlock_workflows/lib/gitlock_workflows/executor.ex
new file mode 100644
index 0000000..f6d7547
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/executor.ex
@@ -0,0 +1,247 @@
+defmodule GitlockWorkflows.Executor do
+  @moduledoc """
+  Executes a workflow pipeline with DAG-based data flow.
+
+  Compiles the visual Pipeline to a Runtime Workflow, then executes nodes
+  in topological order, passing data between nodes through their port
+  connections. This means the git source node fetches commits once and
+  all downstream analyzers receive them through the DAG — no redundant fetches.
+
+  ## Async execution (for LiveView)
+
+  `run/4` spawns a linked Task and sends progress messages to the caller:
+
+      {:pipeline_progress, node_id, :running}
+      {:pipeline_progress, node_id, {:done, result}}
+      {:pipeline_progress, node_id, {:error, reason}}
+      {:pipeline_complete, results}
+
+  ## Sync execution (for CLI and tests)
+
+  `run_sync/3` blocks until all nodes complete and returns the results map.
+  """
+
+  alias GitlockWorkflows.{Pipeline, Node, NodeCatalog, Compiler}
+  alias GitlockWorkflows.Runtime.Registry
+
+  require Logger
+
+  @type node_result :: {:ok, node_output()} | {:error, term()}
+  @type node_output :: %{node_id: String.t(), type: atom(), label: String.t(), data: term()}
+  @type results :: %{String.t() => node_result()}
+
+  # ── Public API ───────────────────────────────────────────────
+
+  @doc """
+  Executes a pipeline asynchronously, sending progress messages to `caller`.
+
+  Returns `:ok` immediately. The caller receives messages as nodes complete.
+
+  ## Options
+
+    * `:format` - Output format: `"json"` or `"csv"` (default: `"json"`)
+    * `:depth` - Git log depth limit
+    * `:branch` - Specific branch to analyze
+  """
+  @spec run(Pipeline.t(), String.t(), pid(), map()) :: :ok
+  def run(%Pipeline{} = pipeline, repo_path, caller \\ self(), options \\ %{}) do
+    Task.start_link(fn ->
+      results = execute_dag(pipeline, repo_path, caller, options)
+      send(caller, {:pipeline_complete, results})
+    end)
+
+    :ok
+  end
+
+  @doc """
+  Executes a pipeline synchronously, returning the results map.
+
+  Blocks until all nodes complete. Useful for CLI invocation and testing.
+  """
+  @spec run_sync(Pipeline.t(), String.t(), map()) :: {:ok, results()} | {:error, term()}
+  def run_sync(%Pipeline{} = pipeline, repo_path, options \\ %{}) do
+    results = execute_dag(pipeline, repo_path, nil, options)
+    {:ok, results}
+  rescue
+    e -> {:error, Exception.message(e)}
+  end
+
+  @doc """
+  Returns the list of executable nodes from a pipeline.
+  Useful for progress tracking — tells the UI how many steps to expect.
+  """
+  @spec executable_nodes(Pipeline.t()) :: [Node.t()]
+  def executable_nodes(%Pipeline{nodes: nodes}) do
+    nodes
+    |> Map.values()
+    |> Enum.filter(fn node -> Compiler.runtime_type(node.type) != nil end)
+  end
+
+  # ── DAG Execution Engine ─────────────────────────────────────
+
+  defp execute_dag(pipeline, repo_path, caller, _options) do
+    case Compiler.to_workflow(pipeline, repo_path: repo_path) do
+      {:ok, workflow} ->
+        run_workflow(workflow, pipeline, caller)
+
+      {:error, reason} ->
+        Logger.error("Failed to compile pipeline: #{inspect(reason)}")
+        %{}
+    end
+  end
+
+  defp run_workflow(workflow, pipeline, caller) do
+    # Build execution structures
+    node_index = Map.new(workflow.nodes, &{&1.id, &1})
+    sorted_ids = topological_sort(workflow)
+    # Map of node_id → %{port_name => data}
+    outputs = %{}
+
+    sorted_ids
+    |> Enum.reduce({outputs, %{}}, fn node_id, {outputs_acc, results_acc} ->
+      node_def = Map.fetch!(node_index, node_id)
+      pipeline_node = Map.get(pipeline.nodes, node_id)
+
+      notify(caller, {:pipeline_progress, node_id, :running})
+
+      # Gather input data from upstream nodes via connections
+      input_data = gather_inputs(node_id, workflow.connections, outputs_acc)
+
+      # Pass caller, node_id, and repo_path in context so nodes can send
+      # sub-step progress and access the repo without explicit wiring
+      context = %{caller: caller, node_id: node_id, repo_path: workflow.repo_path}
+
+      case execute_runtime_node(node_def, input_data, context) do
+        {:ok, output_data} ->
+          label = if pipeline_node, do: pipeline_node.label, else: node_def.type
+          type = if pipeline_node, do: pipeline_node.type, else: String.to_atom(node_def.type)
+
+          notify(caller, {:pipeline_progress, node_id, {:done, output_data}})
+
+          result = {:ok, %{node_id: node_id, type: type, label: label, data: output_data}}
+          {Map.put(outputs_acc, node_id, output_data), Map.put(results_acc, node_id, result)}
+
+        {:error, reason} = err ->
+          Logger.warning("Node #{node_id} (#{node_def.type}) failed: #{inspect(reason)}")
+          notify(caller, {:pipeline_progress, node_id, {:error, reason}})
+
+          {outputs_acc, Map.put(results_acc, node_id, err)}
+      end
+    end)
+    |> elem(1)
+  end
+
+  defp execute_runtime_node(node_def, input_data, context) do
+    case Registry.get_node(node_def.type) do
+      {:ok, module} ->
+        params = node_def.parameters || %{}
+
+        try do
+          module.execute(input_data, params, context)
+        rescue
+          e ->
+            Logger.error("Node #{node_def.id} raised: #{Exception.message(e)}")
+            {:error, Exception.message(e)}
+        end
+
+      {:error, :not_found} ->
+        {:error, "Runtime node not found: #{node_def.type}"}
+    end
+  end
+
+  @doc false
+  def report_status(context, message) when is_map(context) and is_binary(message) do
+    case context do
+      %{caller: caller, node_id: node_id} when is_pid(caller) ->
+        notify(caller, {:pipeline_progress, node_id, {:status, message}})
+
+      _ ->
+        :ok
+    end
+  end
+
+  # ── DAG helpers ──────────────────────────────────────────────
+
+  # Gather input data for a node from upstream outputs via connections
+  defp gather_inputs(node_id, connections, outputs) do
+    connections
+    |> Enum.filter(&(&1.to.node == node_id))
+    |> Enum.reduce(%{}, fn conn, acc ->
+      case Map.get(outputs, conn.from.node) do
+        nil ->
+          acc
+
+        upstream_output when is_map(upstream_output) ->
+          # Extract the specific port's data from upstream output
+          port_key = String.to_atom(conn.from.port)
+          value = Map.get(upstream_output, port_key) || Map.get(upstream_output, conn.from.port)
+
+          if value do
+            input_key = String.to_atom(conn.to.port)
+            Map.put(acc, input_key, value)
+          else
+            acc
+          end
+
+        _ ->
+          acc
+      end
+    end)
+  end
+
+  # Topological sort using Kahn's algorithm
+  defp topological_sort(workflow) do
+    nodes = workflow.nodes
+    connections = workflow.connections
+
+    # Build adjacency list and in-degree count
+    node_ids = MapSet.new(nodes, & &1.id)
+
+    in_degree =
+      Enum.reduce(node_ids, %{}, fn id, acc -> Map.put(acc, id, 0) end)
+
+    {adjacency, in_degree} =
+      Enum.reduce(connections, {%{}, in_degree}, fn conn, {adj, deg} ->
+        adj = Map.update(adj, conn.from.node, [conn.to.node], &[conn.to.node | &1])
+        deg = Map.update(deg, conn.to.node, 1, &(&1 + 1))
+        {adj, deg}
+      end)
+
+    # Start with nodes that have no incoming edges
+    queue =
+      in_degree
+      |> Enum.filter(fn {_id, deg} -> deg == 0 end)
+      |> Enum.map(fn {id, _} -> id end)
+
+    do_topological_sort(queue, adjacency, in_degree, [])
+  end
+
+  defp do_topological_sort([], _adjacency, _in_degree, result), do: Enum.reverse(result)
+
+  defp do_topological_sort([current | rest], adjacency, in_degree, result) do
+    neighbors = Map.get(adjacency, current, [])
+
+    {new_queue_additions, updated_in_degree} =
+      Enum.reduce(neighbors, {[], in_degree}, fn neighbor, {additions, deg} ->
+        new_deg = Map.update!(deg, neighbor, &(&1 - 1))
+
+        if Map.get(new_deg, neighbor) == 0 do
+          {[neighbor | additions], new_deg}
+        else
+          {additions, new_deg}
+        end
+      end)
+
+    do_topological_sort(
+      rest ++ Enum.reverse(new_queue_additions),
+      adjacency,
+      updated_in_degree,
+      [current | result]
+    )
+  end
+
+  # ── Notify ───────────────────────────────────────────────────
+
+  defp notify(nil, _msg), do: :ok
+  defp notify(pid, msg), do: send(pid, msg)
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/node.ex b/apps/gitlock_workflows/lib/gitlock_workflows/node.ex
new file mode 100644
index 0000000..9daebba
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/node.ex
@@ -0,0 +1,101 @@
+defmodule GitlockWorkflows.Node do
+  @moduledoc """
+  A processing step in a workflow pipeline.
+
+  Nodes are created from catalog type definitions and carry their own
+  typed input/output ports. Position is stored for visual layout on
+  the SvelteFlow canvas.
+  """
+
+  alias GitlockWorkflows.{Port, NodeCatalog}
+
+  @type t :: %__MODULE__{
+          id: String.t(),
+          type: atom(),
+          label: String.t(),
+          config: map(),
+          position: {number(), number()},
+          input_ports: [Port.t()],
+          output_ports: [Port.t()]
+        }
+
+  @enforce_keys [:id, :type, :label, :input_ports, :output_ports]
+  defstruct [:id, :type, :label, config: %{}, position: {0, 0}, input_ports: [], output_ports: []]
+
+  @doc """
+  Creates a new node from a catalog type definition.
+
+  ## Options
+    * `:config` - Node-specific configuration (default: `%{}`)
+    * `:position` - Canvas position as `{x, y}` tuple (default: `{0, 0}`)
+
+  ## Returns
+    A `%Node{}` struct on success, or `{:error, :unknown_node_type}`.
+
+  ## Examples
+
+      iex> Node.new(:git_log, config: %{depth: 500}, position: {100, 200})
+      %Node{type: :git_log, label: "Git Log", ...}
+
+      iex> Node.new(:nonexistent)
+      {:error, :unknown_node_type}
+  """
+  @spec new(atom(), keyword()) :: t() | {:error, :unknown_node_type}
+  def new(type_id, opts \\ []) do
+    case NodeCatalog.get_type(type_id) do
+      {:ok, type_def} -> build_from_type_def(type_def, opts)
+      {:error, _} = err -> err
+    end
+  end
+
+  defp build_from_type_def(type_def, opts) do
+    %__MODULE__{
+      id: gen_id(),
+      type: type_def.type_id,
+      label: type_def.label,
+      config: Keyword.get(opts, :config, %{}),
+      position: Keyword.get(opts, :position, {0, 0}),
+      input_ports:
+        Enum.map(
+          type_def.input_ports,
+          &Port.new(&1.name, &1.data_type, optional: Map.get(&1, :optional, false))
+        ),
+      output_ports:
+        Enum.map(
+          type_def.output_ports,
+          &Port.new(&1.name, &1.data_type, optional: Map.get(&1, :optional, false))
+        )
+    }
+  end
+
+  @doc "Finds a port by id across all input and output ports."
+  @spec find_port(t(), String.t()) :: {:ok, Port.t()} | :error
+  def find_port(%__MODULE__{} = node, port_id) do
+    (node.input_ports ++ node.output_ports)
+    |> Enum.find(&(&1.id == port_id))
+    |> case do
+      nil -> :error
+      port -> {:ok, port}
+    end
+  end
+
+  @doc "Finds an output port by id."
+  @spec find_output_port(t(), String.t()) :: {:ok, Port.t()} | :error
+  def find_output_port(%__MODULE__{output_ports: ports}, port_id) do
+    case Enum.find(ports, &(&1.id == port_id)) do
+      nil -> :error
+      port -> {:ok, port}
+    end
+  end
+
+  @doc "Finds an input port by id."
+  @spec find_input_port(t(), String.t()) :: {:ok, Port.t()} | :error
+  def find_input_port(%__MODULE__{input_ports: ports}, port_id) do
+    case Enum.find(ports, &(&1.id == port_id)) do
+      nil -> :error
+      port -> {:ok, port}
+    end
+  end
+
+  defp gen_id, do: :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/node_catalog.ex b/apps/gitlock_workflows/lib/gitlock_workflows/node_catalog.ex
new file mode 100644
index 0000000..e47137e
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/node_catalog.ex
@@ -0,0 +1,627 @@
+defmodule GitlockWorkflows.NodeCatalog do
+  @moduledoc """
+  Registry of available workflow node types.
+
+  Each type definition describes a node's category, ports, configuration
+  schema, and runtime module. This is the **single source of truth** for
+  node definitions — the Compiler and Runtime.Registry both derive their
+  information from here.
+
+  ## Adding a new node type
+
+  1. Create a runtime module implementing `GitlockWorkflows.Runtime.Node`
+  2. Add an entry here with `runtime_module: YourModule`
+  3. That's it — the Compiler will map it, the Registry will register it
+  """
+
+  alias GitlockWorkflows.Port
+
+  @type port_def :: %{name: String.t(), data_type: Port.data_type()}
+
+  @type config_field :: %{
+          key: String.t(),
+          label: String.t(),
+          type: :string | :integer | :select | :date,
+          required: boolean(),
+          default: any(),
+          placeholder: String.t(),
+          options: [%{value: String.t(), label: String.t()}] | nil
+        }
+
+  @type type_def :: %{
+          type_id: atom(),
+          category: :source | :filter | :analyze | :logic | :output,
+          label: String.t(),
+          description: String.t(),
+          input_ports: [port_def()],
+          output_ports: [port_def()],
+          config_schema: [config_field()],
+          runtime_module: module() | nil
+        }
+
+  alias GitlockWorkflows.Runtime.Nodes
+
+  @node_types %{
+    # ── Sources ─────────────────────────────────────────────────
+    git_log: %{
+      type_id: :git_log,
+      category: :source,
+      label: "Git Log",
+      description: "Fetches commit history from a git repository",
+      input_ports: [],
+      output_ports: [
+        %{name: "commits", data_type: :commits}
+      ],
+      runtime_module: Nodes.Triggers.GitCommits,
+      config_schema: [
+        %{
+          key: "repo_url",
+          label: "Repository URL",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "https://github.com/org/repo"
+        },
+        %{
+          key: "branch",
+          label: "Branch",
+          type: :string,
+          required: false,
+          default: "",
+          placeholder: "main (default: all branches)"
+        },
+        %{
+          key: "depth",
+          label: "Commit depth",
+          type: :integer,
+          required: false,
+          default: nil,
+          placeholder: "All commits"
+        },
+        %{
+          key: "since",
+          label: "Since date",
+          type: :date,
+          required: false,
+          default: nil,
+          placeholder: "YYYY-MM-DD"
+        },
+        %{
+          key: "until",
+          label: "Until date",
+          type: :date,
+          required: false,
+          default: nil,
+          placeholder: "YYYY-MM-DD"
+        },
+        %{
+          key: "path_filter",
+          label: "Path filter",
+          type: :string,
+          required: false,
+          default: "",
+          placeholder: "src/ or lib/my_app"
+        }
+      ]
+    },
+
+    # ── Analyzers ───────────────────────────────────────────────
+    hotspot_detection: %{
+      type_id: :hotspot_detection,
+      category: :analyze,
+      label: "Hotspot Detection",
+      description: "Identifies high-change, high-complexity files",
+      input_ports: [
+        %{name: "commits", data_type: :commits},
+        %{name: "complexity_map", data_type: :map, optional: true}
+      ],
+      output_ports: [%{name: "hotspots", data_type: :hotspots}],
+      runtime_module: Nodes.Analysis.Hotspot,
+      config_schema: [
+        %{
+          key: "rows",
+          label: "Max results",
+          type: :integer,
+          required: false,
+          default: nil,
+          placeholder: "All results"
+        }
+      ]
+    },
+    coupling_detection: %{
+      type_id: :coupling_detection,
+      category: :analyze,
+      label: "Coupling Detection",
+      description: "Detects files that change together (temporal coupling)",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "couplings", data_type: :couplings}],
+      runtime_module: Nodes.Analysis.Coupling,
+      config_schema: [
+        %{
+          key: "min_coupling",
+          label: "Min coupling score",
+          type: :integer,
+          required: false,
+          default: 1,
+          placeholder: "1"
+        },
+        %{
+          key: "min_windows",
+          label: "Min time windows",
+          type: :integer,
+          required: false,
+          default: 5,
+          placeholder: "5"
+        }
+      ]
+    },
+    knowledge_silo_detection: %{
+      type_id: :knowledge_silo_detection,
+      category: :analyze,
+      label: "Knowledge Silos",
+      description: "Identifies concentrated code ownership patterns",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "knowledge_silos", data_type: :knowledge_silos}],
+      runtime_module: Nodes.Analysis.KnowledgeSilo,
+      config_schema: []
+    },
+    code_age_analysis: %{
+      type_id: :code_age_analysis,
+      category: :analyze,
+      label: "Code Age",
+      description: "Analyzes how recently code was modified",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "code_age", data_type: :code_age}],
+      runtime_module: Nodes.Analysis.CodeAge,
+      config_schema: []
+    },
+    blast_radius_analysis: %{
+      type_id: :blast_radius_analysis,
+      category: :analyze,
+      label: "Blast Radius",
+      description: "Measures the impact scope of component changes",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "blast_radius", data_type: :blast_radius}],
+      runtime_module: nil,
+      config_schema: []
+    },
+    complexity_analysis: %{
+      type_id: :complexity_analysis,
+      category: :analyze,
+      label: "Complexity Analysis",
+      description: "Analyzes cyclomatic complexity of source files via git",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "complexity_map", data_type: :map}],
+      runtime_module: Nodes.Analysis.Complexity,
+      config_schema: []
+    },
+    coupled_hotspot_analysis: %{
+      type_id: :coupled_hotspot_analysis,
+      category: :analyze,
+      label: "Coupled Hotspots",
+      description: "Finds hotspots that are temporally coupled",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "coupled_hotspots", data_type: :coupled_hotspots}],
+      runtime_module: Nodes.Analysis.CoupledHotspot,
+      config_schema: []
+    },
+    complexity_trend: %{
+      type_id: :complexity_trend,
+      category: :analyze,
+      label: "Complexity Trends",
+      description: "X-ray hotspots to reveal complexity trajectories over time",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "complexity_trends", data_type: :complexity_trends}],
+      runtime_module: Nodes.Analysis.ComplexityTrend,
+      config_schema: [
+        %{
+          key: "max_files",
+          label: "Max files to analyze",
+          type: :integer,
+          required: false,
+          default: 15,
+          placeholder: "15"
+        },
+        %{
+          key: "interval_days",
+          label: "Sample interval (days)",
+          type: :integer,
+          required: false,
+          default: 30,
+          placeholder: "30"
+        }
+      ]
+    },
+    summary: %{
+      type_id: :summary,
+      category: :analyze,
+      label: "Summary",
+      description: "Generates a summary of repository activity",
+      input_ports: [%{name: "commits", data_type: :commits}],
+      output_ports: [%{name: "summary", data_type: :summary}],
+      runtime_module: Nodes.Analysis.Summary,
+      config_schema: []
+    },
+
+    # ── Logic ───────────────────────────────────────────────────
+    filter: %{
+      type_id: :filter,
+      category: :logic,
+      label: "Filter",
+      description: "Keeps items matching a condition",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [
+        %{name: "kept", data_type: :analysis_result},
+        %{name: "rejected", data_type: :analysis_result}
+      ],
+      runtime_module: Nodes.Logic.Filter,
+      config_schema: [
+        %{
+          key: "field",
+          label: "Field",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "risk_factor"
+        },
+        %{
+          key: "operator",
+          label: "Operator",
+          type: :select,
+          required: true,
+          default: "eq",
+          placeholder: "",
+          options: [
+            %{value: "eq", label: "Equals"},
+            %{value: "neq", label: "Not Equals"},
+            %{value: "gt", label: "Greater Than"},
+            %{value: "lt", label: "Less Than"},
+            %{value: "gte", label: "≥"},
+            %{value: "lte", label: "≤"},
+            %{value: "contains", label: "Contains"},
+            %{value: "not_contains", label: "Not Contains"}
+          ]
+        },
+        %{
+          key: "value",
+          label: "Value",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "high"
+        }
+      ]
+    },
+    sort: %{
+      type_id: :sort,
+      category: :logic,
+      label: "Sort",
+      description: "Sorts items by a field value",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [%{name: "items", data_type: :analysis_result}],
+      runtime_module: Nodes.Logic.Sort,
+      config_schema: [
+        %{
+          key: "field",
+          label: "Sort By",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "risk_score"
+        },
+        %{
+          key: "direction",
+          label: "Direction",
+          type: :select,
+          required: false,
+          default: "asc",
+          placeholder: "",
+          options: [%{value: "asc", label: "Ascending"}, %{value: "desc", label: "Descending"}]
+        }
+      ]
+    },
+    limit: %{
+      type_id: :limit,
+      category: :logic,
+      label: "Limit",
+      description: "Takes the first or last N items",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [%{name: "items", data_type: :analysis_result}],
+      runtime_module: Nodes.Logic.Limit,
+      config_schema: [
+        %{
+          key: "count",
+          label: "Count",
+          type: :integer,
+          required: true,
+          default: 10,
+          placeholder: "10"
+        },
+        %{
+          key: "from",
+          label: "From",
+          type: :select,
+          required: false,
+          default: "start",
+          placeholder: "",
+          options: [%{value: "start", label: "First N"}, %{value: "end", label: "Last N"}]
+        }
+      ]
+    },
+    if_condition: %{
+      type_id: :if_condition,
+      category: :logic,
+      label: "IF",
+      description: "Routes items to 'true' or 'false' output based on a condition",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [
+        %{name: "true", data_type: :analysis_result},
+        %{name: "false", data_type: :analysis_result}
+      ],
+      runtime_module: Nodes.Logic.If,
+      config_schema: [
+        %{
+          key: "field",
+          label: "Field",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "risk_factor"
+        },
+        %{
+          key: "operator",
+          label: "Operator",
+          type: :select,
+          required: true,
+          default: "eq",
+          placeholder: "",
+          options: [
+            %{value: "eq", label: "Equals"},
+            %{value: "neq", label: "Not Equals"},
+            %{value: "gt", label: ">"},
+            %{value: "lt", label: "<"},
+            %{value: "gte", label: "≥"},
+            %{value: "lte", label: "≤"},
+            %{value: "is_empty", label: "Is Empty"},
+            %{value: "is_not_empty", label: "Is Not Empty"}
+          ]
+        },
+        %{
+          key: "value",
+          label: "Value",
+          type: :string,
+          required: false,
+          default: "",
+          placeholder: "high"
+        }
+      ]
+    },
+    switch: %{
+      type_id: :switch,
+      category: :logic,
+      label: "Switch",
+      description: "Routes items to different outputs based on a field's value",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [
+        %{name: "case_0", data_type: :analysis_result},
+        %{name: "case_1", data_type: :analysis_result},
+        %{name: "case_2", data_type: :analysis_result},
+        %{name: "case_3", data_type: :analysis_result},
+        %{name: "default", data_type: :analysis_result}
+      ],
+      runtime_module: Nodes.Logic.Switch,
+      config_schema: [
+        %{
+          key: "field",
+          label: "Field",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "risk_factor"
+        },
+        %{
+          key: "cases",
+          label: "Cases",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "high,medium,low"
+        }
+      ]
+    },
+    merge: %{
+      type_id: :merge,
+      category: :logic,
+      label: "Merge",
+      description: "Combines items from two inputs into one output",
+      input_ports: [
+        %{name: "items_a", data_type: :analysis_result},
+        %{name: "items_b", data_type: :analysis_result}
+      ],
+      output_ports: [%{name: "items", data_type: :analysis_result}],
+      runtime_module: Nodes.Logic.Merge,
+      config_schema: [
+        %{
+          key: "mode",
+          label: "Mode",
+          type: :select,
+          required: false,
+          default: "append",
+          placeholder: "",
+          options: [
+            %{value: "append", label: "Append"},
+            %{value: "interleave", label: "Interleave"},
+            %{value: "keep_a", label: "Keep A only"}
+          ]
+        }
+      ]
+    },
+    aggregate: %{
+      type_id: :aggregate,
+      category: :logic,
+      label: "Aggregate",
+      description: "Computes statistics: count, sum, avg, min, max over items",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [%{name: "result", data_type: :analysis_result}],
+      runtime_module: Nodes.Logic.Aggregate,
+      config_schema: [
+        %{
+          key: "operations",
+          label: "Operations",
+          type: :string,
+          required: true,
+          default: "count",
+          placeholder: "count,sum:revisions,avg:risk_score"
+        }
+      ]
+    },
+    remove_duplicates: %{
+      type_id: :remove_duplicates,
+      category: :logic,
+      label: "Remove Duplicates",
+      description: "Removes duplicate items based on a field value",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [%{name: "items", data_type: :analysis_result}],
+      runtime_module: Nodes.Logic.RemoveDuplicates,
+      config_schema: [
+        %{
+          key: "field",
+          label: "Deduplicate By",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "entity"
+        }
+      ]
+    },
+    group_by: %{
+      type_id: :group_by,
+      category: :logic,
+      label: "Group By",
+      description: "Groups items by a field value",
+      input_ports: [%{name: "items", data_type: :analysis_result}],
+      output_ports: [
+        %{name: "groups", data_type: :analysis_result},
+        %{name: "items", data_type: :analysis_result}
+      ],
+      runtime_module: Nodes.Logic.GroupBy,
+      config_schema: [
+        %{
+          key: "field",
+          label: "Group By",
+          type: :string,
+          required: true,
+          default: "",
+          placeholder: "risk_factor"
+        }
+      ]
+    },
+
+    # ── Outputs ─────────────────────────────────────────────────
+    csv_report: %{
+      type_id: :csv_report,
+      category: :output,
+      label: "CSV Report",
+      description: "Formats analysis results as CSV",
+      input_ports: [%{name: "results", data_type: :analysis_result}],
+      output_ports: [],
+      runtime_module: nil,
+      config_schema: [
+        %{
+          key: "rows",
+          label: "Max rows",
+          type: :integer,
+          required: false,
+          default: nil,
+          placeholder: "All rows"
+        }
+      ]
+    },
+    json_report: %{
+      type_id: :json_report,
+      category: :output,
+      label: "JSON Report",
+      description: "Formats analysis results as JSON",
+      input_ports: [%{name: "results", data_type: :analysis_result}],
+      output_ports: [],
+      runtime_module: nil,
+      config_schema: [
+        %{
+          key: "rows",
+          label: "Max rows",
+          type: :integer,
+          required: false,
+          default: nil,
+          placeholder: "All rows"
+        }
+      ]
+    }
+  }
+
+  # ── Public API ───────────────────────────────────────────────
+
+  @doc "Returns all available node type definitions."
+  @spec list_types() :: [type_def()]
+  def list_types, do: Map.values(@node_types)
+
+  @doc "Returns a node type definition by its id."
+  @spec get_type(atom()) :: {:ok, type_def()} | {:error, :unknown_node_type}
+  def get_type(type_id) do
+    case Map.fetch(@node_types, type_id) do
+      {:ok, type_def} -> {:ok, type_def}
+      :error -> {:error, :unknown_node_type}
+    end
+  end
+
+  @doc "Returns the runtime module for a node type, or nil if none."
+  @spec runtime_module(atom()) :: module() | nil
+  def runtime_module(type_id) do
+    case get_type(type_id) do
+      {:ok, %{runtime_module: mod}} -> mod
+      {:error, _} -> nil
+    end
+  end
+
+  @doc """
+  Returns the runtime type string (Registry ID) for a node type.
+
+  Reads the `metadata().id` from the runtime module. Returns nil if the
+  node type has no runtime module.
+  """
+  @spec runtime_type(atom()) :: String.t() | nil
+  def runtime_type(type_id) do
+    case runtime_module(type_id) do
+      nil -> nil
+      mod -> mod.metadata().id
+    end
+  end
+
+  @doc "Returns node type definitions filtered by category."
+  @spec by_category(:source | :filter | :analyze | :logic | :output) :: [type_def()]
+  def by_category(category) do
+    @node_types
+    |> Map.values()
+    |> Enum.filter(&(&1.category == category))
+  end
+
+  @doc "Returns all node types that have runtime modules."
+  @spec executable_types() :: [type_def()]
+  def executable_types do
+    @node_types
+    |> Map.values()
+    |> Enum.filter(&(&1.runtime_module != nil))
+  end
+
+  @doc """
+  Returns all runtime modules from the catalog.
+
+  Used by the Application to register all builtin nodes in the Registry at startup.
+  """
+  @spec runtime_modules() :: [module()]
+  def runtime_modules do
+    @node_types
+    |> Map.values()
+    |> Enum.map(& &1.runtime_module)
+    |> Enum.reject(&is_nil/1)
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/pipeline.ex b/apps/gitlock_workflows/lib/gitlock_workflows/pipeline.ex
new file mode 100644
index 0000000..bf68891
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/pipeline.ex
@@ -0,0 +1,167 @@
+defmodule GitlockWorkflows.Pipeline do
+  @moduledoc """
+  A directed acyclic graph of workflow nodes connected by edges.
+
+  The pipeline is the top-level domain object. It maintains a graph of
+  typed nodes connected through ports, validates structural integrity,
+  and can be compiled into an executable Reactor workflow.
+  """
+
+  alias GitlockWorkflows.{Node, Edge, Port}
+
+  @type t :: %__MODULE__{
+          id: String.t(),
+          name: String.t(),
+          description: String.t(),
+          nodes: %{String.t() => Node.t()},
+          edges: %{String.t() => Edge.t()}
+        }
+
+  @enforce_keys [:id, :name]
+  defstruct [:id, :name, description: "", nodes: %{}, edges: %{}]
+
+  # ── Construction ────────────────────────────────────────────────
+
+  @doc "Creates a new empty pipeline."
+  @spec new(String.t(), keyword()) :: t()
+  def new(name, opts \\ []) do
+    %__MODULE__{
+      id: gen_id(),
+      name: name,
+      description: Keyword.get(opts, :description, "")
+    }
+  end
+
+  # ── Node Operations ────────────────────────────────────────────
+
+  @doc "Adds a node to the pipeline. Returns `{:error, :duplicate_node}` if id exists."
+  @spec add_node(t(), Node.t()) :: t() | {:error, :duplicate_node}
+  def add_node(%__MODULE__{nodes: nodes} = pipeline, %Node{id: id} = node) do
+    if Map.has_key?(nodes, id) do
+      {:error, :duplicate_node}
+    else
+      %{pipeline | nodes: Map.put(nodes, id, node)}
+    end
+  end
+
+  @doc """
+  Removes a node and all edges connected to it.
+  Returns the pipeline unchanged if the node doesn't exist.
+  """
+  @spec remove_node(t(), String.t()) :: t()
+  def remove_node(%__MODULE__{nodes: nodes, edges: edges} = pipeline, node_id) do
+    if Map.has_key?(nodes, node_id) do
+      pruned_edges =
+        edges
+        |> Enum.reject(fn {_id, edge} ->
+          edge.source_node_id == node_id or edge.target_node_id == node_id
+        end)
+        |> Map.new()
+
+      %{pipeline | nodes: Map.delete(nodes, node_id), edges: pruned_edges}
+    else
+      pipeline
+    end
+  end
+
+  # ── Edge Operations ────────────────────────────────────────────
+
+  @doc """
+  Adds an edge connecting two node ports.
+
+  Validates that:
+  - Both nodes exist in the pipeline
+  - The source port exists on the source node (as an output)
+  - The target port exists on the target node (as an input)
+  - The port data types are compatible
+  """
+  @spec add_edge(t(), Edge.t()) :: t() | {:error, atom()}
+  def add_edge(%__MODULE__{} = pipeline, %Edge{} = edge) do
+    with {:ok, source_node} <- fetch_node(pipeline, edge.source_node_id, :source_node_not_found),
+         {:ok, target_node} <- fetch_node(pipeline, edge.target_node_id, :target_node_not_found),
+         {:ok, source_port} <- find_output_port(source_node, edge.source_port_id),
+         {:ok, target_port} <- find_input_port(target_node, edge.target_port_id),
+         :ok <- check_compatibility(source_port, target_port) do
+      %{pipeline | edges: Map.put(pipeline.edges, edge.id, edge)}
+    end
+  end
+
+  @doc "Removes an edge by id."
+  @spec remove_edge(t(), String.t()) :: t()
+  def remove_edge(%__MODULE__{edges: edges} = pipeline, edge_id) do
+    %{pipeline | edges: Map.delete(edges, edge_id)}
+  end
+
+  # ── Validation ─────────────────────────────────────────────────
+
+  @doc """
+  Validates the pipeline graph structure.
+
+  Checks:
+  - All nodes with input ports have those ports connected by an edge
+
+  Returns `:ok` or `{:error, errors}` where errors is a keyword list.
+  """
+  @spec validate(t()) :: :ok | {:error, keyword()}
+  def validate(%__MODULE__{} = pipeline) do
+    errors = check_unconnected_inputs(pipeline)
+
+    if errors == [] do
+      :ok
+    else
+      {:error, errors}
+    end
+  end
+
+  # ── Private Helpers ────────────────────────────────────────────
+
+  defp fetch_node(%__MODULE__{nodes: nodes}, node_id, error_tag) do
+    case Map.fetch(nodes, node_id) do
+      {:ok, node} -> {:ok, node}
+      :error -> {:error, error_tag}
+    end
+  end
+
+  defp find_output_port(node, port_id) do
+    case Node.find_output_port(node, port_id) do
+      {:ok, _} = ok -> ok
+      :error -> {:error, :source_port_not_found}
+    end
+  end
+
+  defp find_input_port(node, port_id) do
+    case Node.find_input_port(node, port_id) do
+      {:ok, _} = ok -> ok
+      :error -> {:error, :target_port_not_found}
+    end
+  end
+
+  defp check_compatibility(source_port, target_port) do
+    if Port.compatible?(source_port, target_port) do
+      :ok
+    else
+      {:error, :incompatible_port_types}
+    end
+  end
+
+  defp check_unconnected_inputs(%__MODULE__{nodes: nodes, edges: edges}) do
+    # Collect all target port ids that have an incoming edge
+    connected_input_ports =
+      edges
+      |> Map.values()
+      |> MapSet.new(& &1.target_port_id)
+
+    # Find nodes with input ports that aren't connected
+    nodes
+    |> Map.values()
+    |> Enum.flat_map(fn node ->
+      node.input_ports
+      |> Enum.reject(&(&1.optional || MapSet.member?(connected_input_ports, &1.id)))
+      |> Enum.map(fn port ->
+        {:unconnected_inputs, "#{node.label} port '#{port.name}' has no incoming connection"}
+      end)
+    end)
+  end
+
+  defp gen_id, do: :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/port.ex b/apps/gitlock_workflows/lib/gitlock_workflows/port.ex
new file mode 100644
index 0000000..70febfc
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/port.ex
@@ -0,0 +1,96 @@
+defmodule GitlockWorkflows.Port do
+  @moduledoc """
+  A typed input or output slot on a workflow node.
+
+  Ports define the data contract between nodes. An edge can only connect
+  an output port to an input port with a compatible data type.
+
+  ## Type hierarchy
+
+      :commits ─────────────────────┐
+      :hotspots ──┐                 │
+      :couplings ─┤                 │
+      :knowledge_silos ─┤           │
+      :code_age ─────────┼→ :analysis_result ──→ :any
+      :blast_radius ─────┤
+      :coupled_hotspots ─┤
+      :summary ──────────┘
+
+  Logic and transform nodes use `:analysis_result` or `:any` for maximum flexibility.
+  """
+
+  @type data_type ::
+          :commits
+          | :hotspots
+          | :couplings
+          | :knowledge_silos
+          | :code_age
+          | :blast_radius
+          | :coupled_hotspots
+          | :complexity_trends
+          | :summary
+          | :analysis_result
+          | :boolean
+          | :any
+          | :text
+
+  @type t :: %__MODULE__{
+          id: String.t(),
+          name: String.t(),
+          data_type: data_type(),
+          optional: boolean()
+        }
+
+  @enforce_keys [:id, :name, :data_type]
+  defstruct [:id, :name, :data_type, optional: false]
+
+  @analysis_subtypes [
+    :hotspots,
+    :couplings,
+    :knowledge_silos,
+    :code_age,
+    :blast_radius,
+    :coupled_hotspots,
+    :complexity_trends,
+    :summary
+  ]
+
+  @doc "Creates a new port with a generated id."
+  @spec new(String.t(), data_type(), keyword()) :: t()
+  def new(name, data_type, opts \\ []) do
+    %__MODULE__{
+      id: gen_id(),
+      name: name,
+      data_type: data_type,
+      optional: Keyword.get(opts, :optional, false)
+    }
+  end
+
+  @doc """
+  Checks whether an output port's type is compatible with an input port's type.
+
+  Compatibility rules (in priority order):
+  1. Exact match is always compatible
+  2. `:any` input accepts everything
+  3. Analysis subtypes are compatible with `:analysis_result`
+  4. `:analysis_result` output is compatible with `:any`
+  """
+  @spec compatible?(t(), t()) :: boolean()
+  def compatible?(%__MODULE__{data_type: same}, %__MODULE__{data_type: same}), do: true
+
+  # :any accepts everything
+  def compatible?(%__MODULE__{}, %__MODULE__{data_type: :any}), do: true
+
+  # Analysis subtypes → :analysis_result
+  def compatible?(%__MODULE__{data_type: source_type}, %__MODULE__{data_type: :analysis_result})
+      when source_type in @analysis_subtypes,
+      do: true
+
+  def compatible?(_, _), do: false
+
+  @doc "Returns the list of analysis subtype atoms."
+  @spec analysis_subtypes() :: [data_type()]
+  def analysis_subtypes, do: @analysis_subtypes
+
+  defp gen_id, do: :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/context.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/context.ex
new file mode 100644
index 0000000..33c90c7
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/context.ex
@@ -0,0 +1,624 @@
+defmodule GitlockWorkflows.Runtime.Context do
+  @moduledoc ~S"""
+  Maintains execution state and provides services to nodes during workflow execution.
+
+  The Context provides:
+  - Execution tracking and identification
+  - Variable storage and retrieval
+  - Temporary storage management
+  - Logging facilities
+  - Metrics collection
+  - Credential management
+  - Workspace access
+
+  ## Usage in Nodes
+
+      defmodule MyNode do
+        def execute(input, params, context) do
+          # Access execution info
+          execution_id = Context.get_execution_id(context)
+          
+          # Store intermediate results
+          Context.set_variable(context, "step_1_result", intermediate_data)
+          
+          # Log progress
+          Context.log(context, :info, "Processing #{length(input.files)} files")
+          
+          # Get workspace path
+          workspace_path = Context.get_workspace_path(context)
+          
+          # Your node logic here
+          {:ok, result}
+        end
+      end
+
+  ## Variable Scope
+
+  Variables stored in the context are available to all nodes in the workflow:
+  - Use for sharing data between nodes
+  - Store intermediate results
+  - Cache expensive computations
+  - Track progress across steps
+
+  ## Logging
+
+  All logs are tagged with execution ID and node ID for traceability:
+  - Logs appear in execution logs
+  - Can be filtered by execution
+  - Include structured metadata
+  """
+
+  require Logger
+
+  @typedoc "Execution context"
+  @type t :: %__MODULE__{
+          execution_id: String.t(),
+          workflow_id: String.t(),
+          workflow_name: String.t() | nil,
+          variables: map(),
+          credentials: map(),
+          temp_storage: String.t(),
+          workspace_path: String.t() | nil,
+          start_time: DateTime.t(),
+          node_executions: map(),
+          tags: map(),
+          options: map()
+        }
+
+  @typedoc "Log level"
+  @type log_level :: :debug | :info | :warning | :error
+
+  @typedoc "Metric value"
+  @type metric_value :: number() | String.t()
+
+  @enforce_keys [:execution_id, :workflow_id, :start_time]
+  defstruct [
+    :execution_id,
+    :workflow_id,
+    :workflow_name,
+    variables: %{},
+    credentials: %{},
+    temp_storage: nil,
+    workspace_path: nil,
+    start_time: nil,
+    node_executions: %{},
+    tags: %{},
+    options: %{}
+  ]
+
+  @doc """
+  Creates a new execution context.
+
+  ## Parameters
+    * `execution_id` - Unique identifier for the execution
+    * `workflow_id` - Identifier of the workflow being executed
+    * `opts` - Additional options
+
+  ## Options
+    * `:workflow_name` - Human-readable name of the workflow
+    * `:workspace_path` - Path to the workspace directory
+    * `:temp_storage` - Path for temporary storage
+    * `:credentials` - Map of credentials for external services
+    * `:tags` - Additional tags for categorization
+    * `:options` - Execution-specific options
+
+  ## Returns
+    A new Context struct
+
+  ## Examples
+
+      context = Context.new("exec_123", "workflow_456", 
+        workflow_name: "Daily Analysis",
+        workspace_path: "/tmp/workspace",
+        tags: %{environment: "production"}
+      )
+  """
+  @spec new(String.t(), String.t(), keyword()) :: t()
+  def new(execution_id, workflow_id, opts \\ []) do
+    temp_storage = Keyword.get(opts, :temp_storage, create_temp_storage(execution_id))
+
+    %__MODULE__{
+      execution_id: execution_id,
+      workflow_id: workflow_id,
+      workflow_name: Keyword.get(opts, :workflow_name),
+      variables: %{},
+      credentials: Keyword.get(opts, :credentials, %{}),
+      temp_storage: temp_storage,
+      workspace_path: Keyword.get(opts, :workspace_path),
+      start_time: DateTime.utc_now(),
+      node_executions: %{},
+      tags: Keyword.get(opts, :tags, %{}),
+      options: Keyword.get(opts, :options, %{})
+    }
+  end
+
+  @doc ~S"""
+  Gets the execution ID from the context.
+
+  ## Parameters
+    * `context` - The execution context
+
+  ## Returns
+    The execution ID as a string
+
+  ## Examples
+
+      execution_id = Context.get_execution_id(context)
+      Logger.info("Starting execution #{execution_id}")
+  """
+  @spec get_execution_id(t()) :: String.t()
+  def get_execution_id(%__MODULE__{execution_id: execution_id}), do: execution_id
+
+  @doc """
+  Gets the workflow ID from the context.
+
+  ## Parameters
+    * `context` - The execution context
+
+  ## Returns
+    The workflow ID as a string
+  """
+  @spec get_workflow_id(t()) :: String.t()
+  def get_workflow_id(%__MODULE__{workflow_id: workflow_id}), do: workflow_id
+
+  @doc ~S"""
+  Gets a variable from the context.
+
+  ## Parameters
+    * `context` - The execution context
+    * `key` - The variable key
+
+  ## Returns
+    The variable value, or `nil` if not found
+
+  ## Examples
+
+      result = Context.get_variable(context, "intermediate_result")
+      
+      case result do
+        nil -> IO.puts("Variable not found")
+        value -> IO.puts("Found result: #{inspect(value)}")
+      end
+  """
+  @spec get_variable(t(), String.t()) :: any()
+  def get_variable(%__MODULE__{variables: variables}, key) do
+    Map.get(variables, key)
+  end
+
+  @doc """
+  Sets a variable in the context.
+
+  ## Parameters
+    * `context` - The execution context
+    * `key` - The variable key
+    * `value` - The variable value
+
+  ## Returns
+    Updated context
+
+  ## Examples
+
+      # Store intermediate result
+      context = Context.set_variable(context, "step_1_output", result)
+      
+      # Store configuration
+      context = Context.set_variable(context, "batch_size", 100)
+      
+      # Store complex data
+      context = Context.set_variable(context, "analysis_cache", %{
+        hotspots: hotspots,
+        complexity: complexity_map
+      })
+  """
+  @spec set_variable(t(), String.t(), any()) :: t()
+  def set_variable(%__MODULE__{} = context, key, value) do
+    %{context | variables: Map.put(context.variables, key, value)}
+  end
+
+  @doc """
+  Gets multiple variables from the context.
+
+  ## Parameters
+    * `context` - The execution context
+    * `keys` - List of variable keys
+
+  ## Returns
+    Map of key-value pairs for found variables
+
+  ## Examples
+
+      vars = Context.get_variables(context, ["result1", "result2", "config"])
+      # Returns: %{"result1" => value1, "config" => config_value}
+      # (missing keys are omitted)
+  """
+  @spec get_variables(t(), [String.t()]) :: map()
+  def get_variables(%__MODULE__{variables: variables}, keys) do
+    Map.take(variables, keys)
+  end
+
+  @doc """
+  Gets all variables from the context.
+
+  ## Parameters
+    * `context` - The execution context
+
+  ## Returns
+    Map of all variables
+
+  ## Examples
+
+      all_vars = Context.list_variables(context)
+      IO.inspect(all_vars, label: "All context variables")
+  """
+  @spec list_variables(t()) :: map()
+  def list_variables(%__MODULE__{variables: variables}), do: variables
+
+  @doc ~S"""
+  Logs a message with the execution context.
+
+  All logs are automatically tagged with execution ID and current node ID
+  for traceability.
+
+  ## Parameters
+    * `context` - The execution context
+    * `level` - Log level (`:debug`, `:info`, `:warning`, `:error`)
+    * `message` - The message to log
+    * `metadata` - Optional additional metadata
+
+  ## Examples
+
+      Context.log(context, :info, "Processing started")
+      Context.log(context, :debug, "Found #{count} files to analyze")
+      Context.log(context, :warning, "Skipping invalid file: #{filename}")
+      Context.log(context, :error, "Analysis failed", %{error: reason})
+  """
+  @spec log(t(), log_level(), String.t(), map()) :: :ok
+  def log(%__MODULE__{} = context, level, message, metadata \\ %{}) do
+    enhanced_metadata =
+      Map.merge(metadata, %{
+        execution_id: context.execution_id,
+        workflow_id: context.workflow_id,
+        workflow_name: context.workflow_name,
+        node_id: get_current_node_id(),
+        tags: context.tags
+      })
+
+    Logger.log(level, message, enhanced_metadata)
+  end
+
+  @doc """
+  Records a metric for the execution.
+
+  Metrics are collected for monitoring and analysis of workflow performance.
+
+  ## Parameters
+    * `context` - The execution context
+    * `metric_name` - Name of the metric
+    * `value` - Metric value
+    * `metadata` - Optional metadata
+
+  ## Examples
+
+      Context.record_metric(context, "files_processed", 150)
+      Context.record_metric(context, "processing_time_ms", 1250)
+      Context.record_metric(context, "memory_usage_mb", 45.2)
+      Context.record_metric(context, "api_calls", 5, %{service: "github"})
+  """
+  @spec record_metric(t(), String.t(), metric_value(), map()) :: :ok
+  def record_metric(%__MODULE__{} = context, metric_name, value, metadata \\ %{}) do
+    metric_metadata =
+      Map.merge(metadata, %{
+        execution_id: context.execution_id,
+        workflow_id: context.workflow_id,
+        node_id: get_current_node_id(),
+        timestamp: DateTime.utc_now()
+      })
+
+    :telemetry.execute(
+      [:gitlock, :runtime, :metric],
+      %{value: value},
+      Map.put(metric_metadata, :metric_name, metric_name)
+    )
+  end
+
+  @doc ~S"""
+  Gets the workspace path for file operations.
+
+  ## Parameters
+    * `context` - The execution context
+
+  ## Returns
+    * `{:ok, path}` - Workspace path available
+    * `{:error, :no_workspace}` - No workspace configured
+
+  ## Examples
+
+      case Context.get_workspace_path(context) do
+        {:ok, path} -> 
+          files = File.ls!(path)
+          IO.puts("Found #{length(files)} files in workspace")
+          
+        {:error, :no_workspace} ->
+          IO.puts("No workspace available")
+      end
+  """
+  @spec get_workspace_path(t()) :: {:ok, String.t()} | {:error, :no_workspace}
+  def get_workspace_path(%__MODULE__{workspace_path: nil}), do: {:error, :no_workspace}
+  def get_workspace_path(%__MODULE__{workspace_path: path}), do: {:ok, path}
+
+  @doc """
+  Gets the temporary storage path.
+
+  This is useful for storing intermediate files during execution.
+
+  ## Parameters
+    * `context` - The execution context
+
+  ## Returns
+    Path to temporary storage directory
+
+  ## Examples
+
+      temp_path = Context.get_temp_storage(context)
+      temp_file = Path.join(temp_path, "intermediate_results.json")
+      File.write!(temp_file, Jason.encode!(data))
+  """
+  @spec get_temp_storage(t()) :: String.t()
+  def get_temp_storage(%__MODULE__{temp_storage: temp_storage}), do: temp_storage
+
+  @doc """
+  Gets a credential value.
+
+  ## Parameters
+    * `context` - The execution context
+    * `key` - The credential key
+
+  ## Returns
+    The credential value, or `nil` if not found
+
+  ## Examples
+
+      case Context.get_credential(context, "github_token") do
+        nil -> {:error, "GitHub token not configured"}
+        token -> {:ok, token}
+      end
+  """
+  @spec get_credential(t(), String.t()) :: String.t() | nil
+  def get_credential(%__MODULE__{credentials: credentials}, key) do
+    Map.get(credentials, key)
+  end
+
+  @doc """
+  Checks if a credential exists.
+
+  ## Parameters
+    * `context` - The execution context
+    * `key` - The credential key
+
+  ## Returns
+    `true` if credential exists, `false` otherwise
+  """
+  @spec has_credential?(t(), String.t()) :: boolean()
+  def has_credential?(%__MODULE__{credentials: credentials}, key) do
+    Map.has_key?(credentials, key)
+  end
+
+  @doc ~S"""
+  Gets execution duration up to now.
+
+  ## Parameters
+    * `context` - The execution context
+
+  ## Returns
+    Duration in milliseconds
+
+  ## Examples
+
+      duration = Context.get_execution_duration(context)
+      Context.log(context, :info, "Execution running for #{duration}ms")
+  """
+  @spec get_execution_duration(t()) :: non_neg_integer()
+  def get_execution_duration(%__MODULE__{start_time: start_time}) do
+    DateTime.diff(DateTime.utc_now(), start_time, :millisecond)
+  end
+
+  @doc """
+  Gets a tag value.
+
+  ## Parameters
+    * `context` - The execution context
+    * `key` - The tag key (string or atom)
+
+  ## Returns
+    The tag value, or `nil` if not found
+
+  ## Examples
+
+      environment = Context.get_tag(context, "environment")
+      
+      case environment do
+        "production" -> use_production_settings()
+        "development" -> use_dev_settings()
+        _ -> use_default_settings()
+      end
+  """
+  @spec get_tag(t(), String.t() | atom()) :: any()
+  def get_tag(%__MODULE__{tags: tags}, key) when is_binary(key) do
+    Map.get(tags, key) || Map.get(tags, String.to_existing_atom(key))
+  rescue
+    ArgumentError -> nil
+  end
+
+  def get_tag(%__MODULE__{tags: tags}, key) when is_atom(key) do
+    Map.get(tags, key) || Map.get(tags, Atom.to_string(key))
+  end
+
+  @doc """
+  Gets an execution option.
+
+  ## Parameters
+    * `context` - The execution context
+    * `key` - The option key
+    * `default` - Default value if not found
+
+  ## Returns
+    The option value, or the default
+
+  ## Examples
+
+      batch_size = Context.get_option(context, "batch_size", 100)
+      timeout = Context.get_option(context, "timeout", 30_000)
+  """
+  @spec get_option(t(), String.t(), any()) :: any()
+  def get_option(%__MODULE__{options: options}, key, default \\ nil) do
+    Map.get(options, key, default)
+  end
+
+  @doc """
+  Records that a node has started execution.
+
+  ## Parameters
+    * `context` - The execution context
+    * `node_id` - The node identifier
+
+  ## Returns
+    Updated context
+
+  ## Examples
+
+      context = Context.record_node_start(context, "hotspot_analysis")
+  """
+  @spec record_node_start(t(), String.t()) :: t()
+  def record_node_start(%__MODULE__{} = context, node_id) do
+    node_execution = %{
+      node_id: node_id,
+      started_at: DateTime.utc_now(),
+      completed_at: nil,
+      status: :running,
+      error: nil
+    }
+
+    %{context | node_executions: Map.put(context.node_executions, node_id, node_execution)}
+  end
+
+  @doc """
+  Records that a node has completed execution.
+
+  ## Parameters
+    * `context` - The execution context
+    * `node_id` - The node identifier
+    * `result` - The execution result (`:ok` or `{:error, reason}`)
+
+  ## Returns
+    Updated context
+  """
+  @spec record_node_completion(t(), String.t(), :ok | {:error, term()}) :: t()
+  def record_node_completion(%__MODULE__{} = context, node_id, result) do
+    case get_in(context.node_executions, [node_id]) do
+      nil ->
+        # Node wasn't recorded as started, create a completed record
+        node_execution = %{
+          node_id: node_id,
+          started_at: DateTime.utc_now(),
+          completed_at: DateTime.utc_now(),
+          status: if(result == :ok, do: :completed, else: :failed),
+          error: if(result == :ok, do: nil, else: elem(result, 1))
+        }
+
+        %{context | node_executions: Map.put(context.node_executions, node_id, node_execution)}
+
+      node_execution ->
+        # Update existing record
+        updated_execution = %{
+          node_execution
+          | completed_at: DateTime.utc_now(),
+            status: if(result == :ok, do: :completed, else: :failed),
+            error: if(result == :ok, do: nil, else: elem(result, 1))
+        }
+
+        %{context | node_executions: Map.put(context.node_executions, node_id, updated_execution)}
+    end
+  end
+
+  @doc """
+  Gets the execution status of a node.
+
+  ## Parameters
+    * `context` - The execution context
+    * `node_id` - The node identifier
+
+  ## Returns
+    Node execution info, or `nil` if not found
+  """
+  @spec get_node_execution(t(), String.t()) :: map() | nil
+  def get_node_execution(%__MODULE__{node_executions: node_executions}, node_id) do
+    Map.get(node_executions, node_id)
+  end
+
+  @doc """
+  Creates a child context for a specific node.
+
+  This is useful when you need to isolate variables or state for a specific node.
+
+  ## Parameters
+    * `context` - The parent execution context
+    * `node_id` - The node identifier
+
+  ## Returns
+    A new context with the node ID set
+
+  ## Examples
+
+      node_context = Context.create_node_context(context, "hotspot_analysis")
+      # Node-specific operations...
+  """
+  @spec create_node_context(t(), String.t()) :: t()
+  def create_node_context(%__MODULE__{} = context, node_id) do
+    # For now, we just store the node ID in the process dictionary
+    # In a more sophisticated implementation, you might create a separate context
+    Process.put(:current_node_id, node_id)
+    context
+  end
+
+  @doc """
+  Converts context to a map for serialization.
+
+  ## Parameters
+    * `context` - The execution context
+
+  ## Returns
+    Map representation of the context
+
+  ## Examples
+
+      context_map = Context.to_map(context)
+      json = Jason.encode!(context_map)
+  """
+  @spec to_map(t()) :: map()
+  def to_map(%__MODULE__{} = context) do
+    %{
+      execution_id: context.execution_id,
+      workflow_id: context.workflow_id,
+      workflow_name: context.workflow_name,
+      variables: context.variables,
+      temp_storage: context.temp_storage,
+      workspace_path: context.workspace_path,
+      start_time: context.start_time,
+      node_executions: context.node_executions,
+      tags: context.tags,
+      options: context.options
+    }
+  end
+
+  # Private Functions
+
+  defp create_temp_storage(execution_id) do
+    base_path = Path.join([System.tmp_dir!(), "gitlock", "runtime", "executions", execution_id])
+    File.mkdir_p!(base_path)
+    base_path
+  end
+
+  defp get_current_node_id do
+    Process.get(:current_node_id)
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/engine.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/engine.ex
new file mode 100644
index 0000000..a8d58ee
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/engine.ex
@@ -0,0 +1,886 @@
+defmodule GitlockWorkflows.Runtime.Engine do
+  @moduledoc """
+  Orchestrates workflow execution and manages execution lifecycle.
+
+  The Engine is responsible for:
+  - Loading and preparing workflows for execution
+  - Converting workflows to Reactor instances
+  - Managing execution state and progress
+  - Handling async execution with monitoring
+  - Emitting execution events for real-time updates
+
+  ## Usage
+
+      # Synchronous execution
+      {:ok, result} = Engine.execute_sync(workflow, %{repo_path: "/path/to/repo"})
+
+      # Asynchronous execution with monitoring
+      {:ok, execution_id} = Engine.execute(workflow, %{repo_path: "/path/to/repo"})
+      Engine.subscribe_to_execution(execution_id)
+
+  ## Execution States
+
+  - `:pending` - Execution queued but not started
+  - `:running` - Currently executing
+  - `:completed` - Execution finished successfully
+  """
+  use GenServer
+  require Logger
+
+  alias GitlockWorkflows.Runtime.{Workflow, Validator}
+
+  @typedoc "Execution status information"
+  @type execution_status :: %{
+          id: String.t(),
+          workflow_id: String.t(),
+          state: execution_state(),
+          progress: float(),
+          started_at: DateTime.t() | nil,
+          completed_at: DateTime.t() | nil,
+          result: term() | nil,
+          error: term() | nil,
+          metrics: execution_metrics()
+        }
+
+  @typedoc "Execution state"
+  @type execution_state :: :pending | :running | :completed
+
+  @typedoc "Execution metrics"
+  @type execution_metrics :: %{
+          nodes_total: non_neg_integer(),
+          nodes_completed: non_neg_integer(),
+          nodes_failed: non_neg_integer(),
+          duration_ms: non_neg_integer() | nil,
+          memory_usage_mb: float() | nil
+        }
+
+  @typedoc "Execution options"
+  @type execution_opts :: [
+          {:async, boolean()},
+          {:timeout, timeout()},
+          {:max_retries, non_neg_integer()},
+          {:telemetry_enabled, boolean()}
+        ]
+
+  # Client API
+
+  @doc """
+  Starts the execution engine.
+
+  Usually called by the supervisor.
+  """
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+  end
+
+  @doc """
+  Executes a workflow asynchronously.
+
+  Returns immediately with an execution ID. Use `get_execution_status/1` or
+  subscribe to telemetry events to monitor progress.
+
+  ## Parameters
+    * `workflow` - The workflow to execute
+    * `initial_data` - Initial data to pass to the workflow
+    * `opts` - Execution options
+
+  ## Options
+    * `:timeout` - Maximum execution time (default: 30 minutes)
+    * `:max_retries` - Maximum number of retries per node (default: 3)
+    * `:telemetry_enabled` - Enable telemetry events (default: true)
+
+  ## Returns
+    * `{:ok, execution_id}` - Execution started successfully
+    * `{:error, reason}` - Failed to start execution
+
+  ## Examples
+
+      workflow = %Workflow{...}
+      {:ok, execution_id} = Engine.execute(workflow, %{repo_path: "/my/repo"})
+      
+      # Monitor progress
+      Engine.subscribe_to_execution(execution_id)
+      
+      # Check status
+      {:ok, status} = Engine.get_execution_status(execution_id)
+  """
+  @spec execute(Workflow.t(), map(), execution_opts()) :: {:ok, String.t()} | {:error, term()}
+  def execute(%Workflow{} = workflow, initial_data \\ %{}, opts \\ []) do
+    GenServer.call(__MODULE__, {:execute, workflow, initial_data, opts})
+  end
+
+  @doc ~S"""
+  Executes a workflow synchronously.
+
+  Blocks until the workflow completes or fails. For long-running workflows,
+  consider using `execute/3` with telemetry monitoring instead.
+
+  ## Parameters
+    * `workflow` - The workflow to execute
+    * `initial_data` - Initial data to pass to the workflow
+    * `opts` - Execution options
+
+  ## Returns
+    * `{:ok, result}` - Execution completed successfully
+    * `{:error, reason}` - Execution failed
+
+  ## Examples
+
+      workflow = %Workflow{...}
+      case Engine.execute_sync(workflow, %{repo_path: "/my/repo"}) do
+        {:ok, result} -> 
+          IO.puts("Hotspots found: #{length(result.hotspots)}")
+        {:error, reason} -> 
+          IO.puts("Analysis failed: #{reason}")
+      end
+  """
+  @spec execute_sync(Workflow.t(), map(), execution_opts()) :: {:ok, term()} | {:error, term()}
+  def execute_sync(%Workflow{} = workflow, initial_data \\ %{}, opts \\ []) do
+    opts = Keyword.put(opts, :async, false)
+
+    case execute(workflow, initial_data, opts) do
+      {:ok, execution_id} ->
+        wait_for_completion(execution_id, Keyword.get(opts, :timeout, :timer.minutes(30)))
+
+      error ->
+        error
+    end
+  end
+
+  @doc ~S"""
+  Gets the current status of an execution.
+
+  ## Parameters
+    * `execution_id` - ID of the execution
+
+  ## Returns
+    * `{:ok, execution_status}` - Status retrieved successfully
+    * `{:error, :not_found}` - Execution not found
+    * `{:error, reason}` - Failed to get status
+
+  ## Examples
+
+      {:ok, status} = Engine.get_execution_status(execution_id)
+      
+      case status.state do
+        :running -> IO.puts("Progress: #{status.progress}%")
+        :completed -> IO.puts("Completed at #{status.completed_at}")
+        :failed -> IO.puts("Failed: #{status.error}")
+      end
+  """
+  @spec get_execution_status(String.t()) :: {:ok, execution_status()} | {:error, term()}
+  def get_execution_status(execution_id) do
+    GenServer.call(__MODULE__, {:get_execution_status, execution_id})
+  end
+
+  @doc """
+  Lists all executions, optionally filtered.
+
+  ## Parameters
+    * `filters` - Optional filters to apply
+
+  ## Filter Options
+    * `:workflow_id` - Filter by workflow ID
+    * `:state` - Filter by execution state
+    * `:limit` - Maximum number of results
+    * `:offset` - Number of results to skip
+
+  ## Returns
+    List of execution status summaries
+
+  ## Examples
+
+      # Get all executions
+      executions = Engine.list_executions()
+      
+      # Get running executions for a workflow
+      running = Engine.list_executions(%{workflow_id: "wf_123", state: :running})
+      
+      # Get recent executions
+      recent = Engine.list_executions(%{limit: 10, offset: 0})
+  """
+  @spec list_executions(map()) :: [execution_status()]
+  def list_executions(filters \\ %{}) do
+    GenServer.call(__MODULE__, {:list_executions, filters})
+  end
+
+  @doc ~S"""
+  Subscribes to execution events.
+
+  The calling process will receive messages about execution progress:
+  - `{:execution_started, execution_id}`
+  - `{:execution_progress, execution_id, progress}`
+  - `{:execution_completed, execution_id, result}`
+  - `{:execution_failed, execution_id, error}`
+  - `{:execution_cancelled, execution_id}`
+
+  ## Parameters
+    * `execution_id` - ID of the execution to monitor
+
+  ## Returns
+    * `:ok` - Subscription successful
+    * `{:error, reason}` - Subscription failed
+
+  ## Examples
+
+      {:ok, execution_id} = Engine.execute(workflow, data)
+      :ok = Engine.subscribe_to_execution(execution_id)
+      
+      receive do
+        {:execution_completed, ^execution_id, result} ->
+          IO.puts("Workflow completed successfully!")
+        {:execution_failed, ^execution_id, error} ->
+          IO.puts("Workflow failed: #{inspect(error)}")
+      after
+        60_000 -> IO.puts("Timeout waiting for completion")
+      end
+  """
+  @spec subscribe_to_execution(String.t()) :: :ok | {:error, term()}
+  def subscribe_to_execution(execution_id) do
+    GenServer.call(__MODULE__, {:subscribe_to_execution, execution_id, self()})
+  end
+
+  @doc """
+  Unsubscribes from execution events.
+
+  ## Parameters
+    * `execution_id` - ID of the execution to stop monitoring
+
+  ## Returns
+    * `:ok` - Unsubscription successful
+    * `{:error, reason}` - Unsubscription failed
+  """
+  @spec unsubscribe_from_execution(String.t()) :: :ok | {:error, term()}
+  def unsubscribe_from_execution(execution_id) do
+    GenServer.call(__MODULE__, {:unsubscribe_from_execution, execution_id, self()})
+  end
+
+  @doc ~S"""
+  Gets engine statistics and metrics.
+
+  ## Returns
+    * `map()` - Statistics including total executions, success rate, etc.
+
+  ## Examples
+
+      stats = Engine.get_stats()
+      IO.puts("Total executions: #{stats.total_executions}")
+      IO.puts("Success rate: #{stats.success_rate}%")
+  """
+  @spec get_stats() :: map()
+  def get_stats do
+    GenServer.call(__MODULE__, :get_stats)
+  end
+
+  # Server Implementation
+
+  @impl GenServer
+  def init(_opts) do
+    Logger.info("Starting Runtime.Engine")
+
+    # Subscribe to CORRECT Reactor telemetry events
+    attach_telemetry_handlers()
+
+    state = %{
+      executions: %{},
+      subscribers: %{},
+      metrics: %{
+        total_executions: 0,
+        successful_executions: 0,
+        failed_executions: 0
+      }
+    }
+
+    {:ok, state}
+  end
+
+  @impl GenServer
+  def handle_call({:execute, workflow, initial_data, opts}, _from, state) do
+    case prepare_execution(workflow, initial_data, opts) do
+      {:ok, execution_id, execution_state} ->
+        new_state = put_in(state, [:executions, execution_id], execution_state)
+
+        # Update total executions metric
+        new_state = update_in(new_state, [:metrics, :total_executions], &(&1 + 1))
+
+        # Start execution asynchronously
+        start_execution_task(execution_id, workflow, initial_data, opts)
+
+        {:reply, {:ok, execution_id}, new_state}
+
+      {:error, reason} ->
+        {:reply, {:error, reason}, state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call({:get_execution_status, execution_id}, _from, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:reply, {:error, :not_found}, state}
+
+      execution ->
+        status = build_execution_status(execution)
+        {:reply, {:ok, status}, state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call({:list_executions, filters}, _from, state) do
+    executions =
+      state.executions
+      |> Map.values()
+      |> apply_filters(filters)
+      |> Enum.map(&build_execution_status/1)
+
+    {:reply, executions, state}
+  end
+
+  @impl GenServer
+  def handle_call({:subscribe_to_execution, execution_id, pid}, _from, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:reply, {:error, :not_found}, state}
+
+      _execution ->
+        # Add subscriber
+        subscribers = Map.get(state.subscribers, execution_id, MapSet.new())
+        updated_subscribers = MapSet.put(subscribers, pid)
+        new_state = put_in(state, [:subscribers, execution_id], updated_subscribers)
+
+        # Monitor the subscriber process
+        Process.monitor(pid)
+
+        {:reply, :ok, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call({:unsubscribe_from_execution, execution_id, pid}, _from, state) do
+    case get_in(state, [:subscribers, execution_id]) do
+      nil ->
+        {:reply, :ok, state}
+
+      subscribers ->
+        updated_subscribers = MapSet.delete(subscribers, pid)
+        new_state = put_in(state, [:subscribers, execution_id], updated_subscribers)
+        {:reply, :ok, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call(:get_stats, _from, state) do
+    total = state.metrics.total_executions
+    successful = state.metrics.successful_executions
+    failed = state.metrics.failed_executions
+
+    success_rate = if total > 0, do: Float.round(successful / total * 100, 2), else: 0.0
+
+    stats = %{
+      total_executions: total,
+      successful_executions: successful,
+      failed_executions: failed,
+      success_rate: success_rate,
+      active_executions: count_active_executions(state.executions)
+    }
+
+    {:reply, stats, state}
+  end
+
+  @impl GenServer
+  def handle_info({:execution_started, execution_id}, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:noreply, state}
+
+      execution ->
+        updated_execution = %{
+          execution
+          | state: :running,
+            started_at: DateTime.utc_now()
+        }
+
+        new_state = put_in(state, [:executions, execution_id], updated_execution)
+
+        # Notify subscribers
+        notify_subscribers(execution_id, {:execution_started, execution_id}, new_state)
+
+        {:noreply, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_info({:execution_completed, execution_id, result}, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:noreply, state}
+
+      execution ->
+        updated_execution = %{
+          execution
+          | state: :completed,
+            result: result,
+            completed_at: DateTime.utc_now(),
+            metrics: calculate_final_metrics(execution)
+        }
+
+        new_state = put_in(state, [:executions, execution_id], updated_execution)
+
+        # Update global metrics
+        new_state = update_in(new_state, [:metrics, :successful_executions], &(&1 + 1))
+
+        # Notify subscribers
+        notify_subscribers(execution_id, {:execution_completed, execution_id, result}, new_state)
+
+        {:noreply, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_info({:execution_failed, execution_id, error}, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:noreply, state}
+
+      execution ->
+        updated_execution = %{
+          execution
+          | state: :failed,
+            error: error,
+            completed_at: DateTime.utc_now(),
+            metrics: calculate_final_metrics(execution)
+        }
+
+        new_state = put_in(state, [:executions, execution_id], updated_execution)
+
+        # Update global metrics
+        new_state = update_in(new_state, [:metrics, :failed_executions], &(&1 + 1))
+
+        # Notify subscribers
+        notify_subscribers(execution_id, {:execution_failed, execution_id, error}, new_state)
+
+        {:noreply, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_info({:execution_progress, execution_id, progress}, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:noreply, state}
+
+      execution ->
+        updated_execution = %{execution | progress: progress}
+        new_state = put_in(state, [:executions, execution_id], updated_execution)
+
+        # Notify subscribers
+        notify_subscribers(execution_id, {:execution_progress, execution_id, progress}, new_state)
+
+        {:noreply, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_info({:node_completed, execution_id, node_id}, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:noreply, state}
+
+      execution ->
+        # Update metrics - increment completed nodes
+        updated_metrics = %{
+          execution.metrics
+          | nodes_completed: execution.metrics.nodes_completed + 1
+        }
+
+        updated_execution = %{execution | metrics: updated_metrics}
+        new_state = put_in(state, [:executions, execution_id], updated_execution)
+
+        # Notify subscribers
+        notify_subscribers(execution_id, {:node_completed, execution_id, node_id}, new_state)
+
+        {:noreply, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_info({:node_failed, execution_id, node_id, error}, state) do
+    case get_in(state, [:executions, execution_id]) do
+      nil ->
+        {:noreply, state}
+
+      execution ->
+        # Update metrics - increment failed nodes
+        updated_metrics = %{
+          execution.metrics
+          | nodes_failed: execution.metrics.nodes_failed + 1
+        }
+
+        updated_execution = %{execution | metrics: updated_metrics}
+        new_state = put_in(state, [:executions, execution_id], updated_execution)
+
+        # Notify subscribers
+        notify_subscribers(execution_id, {:node_failed, execution_id, node_id, error}, new_state)
+
+        {:noreply, new_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_info({:DOWN, _ref, :process, pid, _reason}, state) do
+    # Remove dead subscriber from all subscriptions
+    new_subscribers =
+      state.subscribers
+      |> Enum.map(fn {execution_id, subscribers} ->
+        {execution_id, MapSet.delete(subscribers, pid)}
+      end)
+      |> Map.new()
+
+    {:noreply, %{state | subscribers: new_subscribers}}
+  end
+
+  # Private Functions
+
+  defp prepare_execution(workflow, initial_data, opts) do
+    # Validate workflow
+    case Validator.validate_workflow(workflow) do
+      {:ok, validated_workflow} ->
+        # Convert to Reactor
+        case Workflow.to_reactor(validated_workflow) do
+          {:ok, reactor_workflow} ->
+            execution_id = generate_execution_id()
+
+            execution_state = %{
+              id: execution_id,
+              workflow_id: workflow.id,
+              workflow: reactor_workflow,
+              state: :pending,
+              progress: 0.0,
+              started_at: nil,
+              completed_at: nil,
+              result: nil,
+              error: nil,
+              initial_data: initial_data,
+              opts: opts,
+              metrics: %{
+                nodes_total: length(workflow.nodes),
+                nodes_completed: 0,
+                nodes_failed: 0,
+                duration_ms: nil,
+                memory_usage_mb: nil
+              }
+            }
+
+            {:ok, execution_id, execution_state}
+
+          {:error, reason} ->
+            {:error, {:reactor_conversion_failed, reason}}
+        end
+
+      {:error, reason} ->
+        {:error, {:validation_failed, reason}}
+    end
+  end
+
+  defp start_execution_task(execution_id, workflow, initial_data, opts) do
+    engine_pid = self()
+
+    Task.start(fn ->
+      Logger.info("Starting execution task for #{execution_id}")
+
+      try do
+        # Send started event
+        send(engine_pid, {:execution_started, execution_id})
+
+        # Execute the workflow
+        case Workflow.to_reactor(workflow) do
+          {:ok, reactor_workflow} ->
+            Logger.info("Successfully converted workflow to reactor")
+
+            # Setup execution context with proper telemetry metadata
+            context = %{
+              execution_id: execution_id,
+              workflow_id: workflow.id,
+              # Add telemetry metadata for Reactor middleware
+              telemetry_metadata: %{
+                execution_id: execution_id,
+                workflow_id: workflow.id
+              }
+            }
+
+            # Enable telemetry middleware - THIS IS CRUCIAL
+            reactor_opts = [
+              context: context,
+              async?: Keyword.get(opts, :async, true),
+              max_retries: Keyword.get(opts, :max_retries, 3),
+              # Enable telemetry middleware
+              middleware: [
+                {Reactor.Middleware.Telemetry, []}
+              ]
+            ]
+
+            Logger.info("About to call Reactor.run with context: #{inspect(context)}")
+
+            case Reactor.run(reactor_workflow.reactor, initial_data, reactor_opts) do
+              {:ok, result} ->
+                Logger.info("Reactor.run succeeded")
+                send(engine_pid, {:execution_completed, execution_id, result})
+
+              {:error, reason} ->
+                Logger.error("Reactor.run failed: #{inspect(reason)}")
+                send(engine_pid, {:execution_failed, execution_id, reason})
+            end
+
+          {:error, reason} ->
+            Logger.error("Failed to convert workflow to reactor: #{inspect(reason)}")
+            send(engine_pid, {:execution_failed, execution_id, reason})
+        end
+      rescue
+        error ->
+          Logger.error("Exception in execution task: #{inspect(error)}")
+          send(engine_pid, {:execution_failed, execution_id, error})
+      end
+    end)
+  end
+
+  defp wait_for_completion(execution_id, timeout) do
+    receive do
+      {:execution_completed, ^execution_id, result} ->
+        {:ok, result}
+
+      {:execution_failed, ^execution_id, error} ->
+        {:error, error}
+
+      {:execution_cancelled, ^execution_id} ->
+        {:error, :cancelled}
+    after
+      timeout ->
+        {:error, :timeout}
+    end
+  end
+
+  defp build_execution_status(execution) do
+    %{
+      id: execution.id,
+      workflow_id: execution.workflow_id,
+      state: execution.state,
+      progress: execution.progress,
+      started_at: execution.started_at,
+      completed_at: execution.completed_at,
+      result: execution.result,
+      error: execution.error,
+      metrics: execution.metrics
+    }
+  end
+
+  defp apply_filters(executions, filters) do
+    Enum.filter(executions, fn execution ->
+      Enum.all?(filters, fn
+        {:workflow_id, workflow_id} -> execution.workflow_id == workflow_id
+        {:state, state} -> execution.state == state
+        # Handle limit separately
+        {:limit, _} -> true
+        # Handle offset separately
+        {:offset, _} -> true
+        _ -> true
+      end)
+    end)
+    |> maybe_limit_offset(filters)
+  end
+
+  defp maybe_limit_offset(executions, filters) do
+    executions
+    |> maybe_offset(Map.get(filters, :offset))
+    |> maybe_limit(Map.get(filters, :limit))
+  end
+
+  defp maybe_offset(executions, nil), do: executions
+  defp maybe_offset(executions, offset), do: Enum.drop(executions, offset)
+
+  defp maybe_limit(executions, nil), do: executions
+  defp maybe_limit(executions, limit), do: Enum.take(executions, limit)
+
+  defp notify_subscribers(execution_id, message, state) do
+    case get_in(state, [:subscribers, execution_id]) do
+      nil ->
+        :ok
+
+      subscribers ->
+        Enum.each(subscribers, fn pid ->
+          send(pid, message)
+        end)
+    end
+  end
+
+  defp calculate_final_metrics(execution) do
+    duration =
+      if execution.started_at && execution.completed_at do
+        DateTime.diff(execution.completed_at, execution.started_at, :millisecond)
+      else
+        nil
+      end
+
+    %{
+      execution.metrics
+      | duration_ms: duration,
+        memory_usage_mb: get_memory_usage()
+    }
+  end
+
+  defp get_memory_usage do
+    case :erlang.memory(:total) do
+      memory when is_integer(memory) -> memory / 1024 / 1024
+      _ -> nil
+    end
+  end
+
+  defp generate_execution_id do
+    "exec_" <> (:crypto.strong_rand_bytes(8) |> Base.url_encode64(padding: false))
+  end
+
+  defp count_active_executions(executions) do
+    executions
+    |> Map.values()
+    |> Enum.count(fn execution ->
+      execution.state in [:pending, :running, :paused]
+    end)
+  end
+
+  defp attach_telemetry_handlers do
+    # Attach to the CORRECT Reactor telemetry events
+    events = [
+      # Reactor run events
+      [:reactor, :run, :start],
+      [:reactor, :run, :stop],
+      # Reactor step events - THESE ARE THE CORRECT NAMES
+      [:reactor, :step, :run, :start],
+      [:reactor, :step, :run, :stop],
+      # Process events for concurrent execution
+      [:reactor, :step, :process, :start],
+      [:reactor, :step, :process, :stop],
+      # Compensation events for saga rollback
+      [:reactor, :step, :compensate, :start],
+      [:reactor, :step, :compensate, :stop],
+      # Undo events for transaction rollback
+      [:reactor, :step, :undo, :start],
+      [:reactor, :step, :undo, :stop]
+    ]
+
+    Logger.info("Attaching telemetry handlers for events: #{inspect(events)}")
+
+    # Use a module function instead of anonymous function to avoid performance warning
+    :telemetry.attach_many(
+      "runtime-engine-reactor",
+      events,
+      &__MODULE__.handle_telemetry_event/4,
+      %{}
+    )
+  end
+
+  # Make the telemetry handler a public module function
+  def handle_telemetry_event([:reactor, :run, :start], _measurements, metadata, _config) do
+    # Extract execution_id from telemetry metadata
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      Logger.debug("Reactor run started for execution: #{execution_id}")
+      # Engine already handles execution start, so we don't need to do anything here
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :run, :stop], _measurements, metadata, _config) do
+    # Extract execution_id from telemetry metadata
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      Logger.debug("Reactor run stopped for execution: #{execution_id}")
+      # Engine will handle completion based on success/failure
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :run, :start], _measurements, metadata, _config) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      # Get the engine PID and send progress update
+      if engine_pid = GenServer.whereis(__MODULE__) do
+        Logger.debug("Step started for execution: #{execution_id}")
+        send(engine_pid, {:execution_progress, execution_id, calculate_progress(metadata)})
+      end
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :run, :stop], _measurements, metadata, _config) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      # Get the engine PID and send progress update
+      if engine_pid = GenServer.whereis(__MODULE__) do
+        step_name = get_step_name_from_metadata(metadata)
+        Logger.debug("Step completed for execution: #{execution_id}, step: #{step_name}")
+        send(engine_pid, {:node_completed, execution_id, step_name})
+        send(engine_pid, {:execution_progress, execution_id, calculate_progress(metadata)})
+      end
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :process, :start], _, metadata, _) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      step_name = get_step_name_from_metadata(metadata)
+      Logger.debug("Step process started for execution: #{execution_id}, step: #{step_name}")
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :process, :stop], _measurements, metadata, _config) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      step_name = get_step_name_from_metadata(metadata)
+      Logger.debug("Step process stopped for execution: #{execution_id}, step: #{step_name}")
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :compensate, :start], _, metadata, _) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      step_name = get_step_name_from_metadata(metadata)
+      Logger.debug("Step compensation started for execution: #{execution_id}, step: #{step_name}")
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :compensate, :stop], _, metadata, _) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      step_name = get_step_name_from_metadata(metadata)
+      Logger.debug("Step compensation stopped for execution: #{execution_id}, step: #{step_name}")
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :undo, :start], _measurements, metadata, _config) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      step_name = get_step_name_from_metadata(metadata)
+      Logger.debug("Step undo started for execution: #{execution_id}, step: #{step_name}")
+    end
+  end
+
+  def handle_telemetry_event([:reactor, :step, :undo, :stop], _measurements, metadata, _config) do
+    if execution_id = get_execution_id_from_metadata(metadata) do
+      step_name = get_step_name_from_metadata(metadata)
+      Logger.debug("Step undo stopped for execution: #{execution_id}, step: #{step_name}")
+    end
+  end
+
+  # Helper functions to extract data from Reactor telemetry metadata
+  defp get_execution_id_from_metadata(metadata) do
+    # Try different possible locations for execution_id
+    metadata[:execution_id] ||
+      get_in(metadata, [:telemetry_metadata, :execution_id]) ||
+      get_in(metadata, [:context, :execution_id])
+  end
+
+  defp get_step_name_from_metadata(metadata) do
+    # Try different possible locations for step name
+    case metadata[:step] do
+      %{name: name} -> to_string(name)
+      step when is_binary(step) -> step
+      step when is_atom(step) -> to_string(step)
+      _ -> "unknown"
+    end
+  end
+
+  defp calculate_progress(metadata) do
+    # This is a simplified progress calculation
+    # In a real implementation, you'd track completed vs total steps
+    # For now, we'll just return a fixed value
+    50.0
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/node.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/node.ex
new file mode 100644
index 0000000..22de1dd
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/node.ex
@@ -0,0 +1,209 @@
+defmodule GitlockWorkflows.Runtime.Node do
+  @moduledoc """
+  Defines the contract all nodes must implement.
+
+  This module serves as a behaviour definition for nodes. All workflow nodes 
+  must implement this behaviour to be usable in the runtime.
+
+  Node registration and discovery is now handled by GitlockWorkflows.Runtime.Registry.
+
+  ## Node Types
+
+  Nodes are categorized into:
+  - **Triggers**: Start workflow execution (no input ports)
+  - **Analysis**: Wrap existing Gitlock use cases
+  - **Transform**: Manipulate data between analysis steps
+  - **Output**: Send results to external systems (no output ports)
+
+  ## Port Types
+
+  The runtime supports these port types:
+  - `:string` - Text data
+  - `:number` - Numeric values (integer or float)
+  - `:boolean` - True/false values
+  - `{:list, type}` - List of values of the specified type
+  - `{:map, type}` - Map with values of the specified type
+  - `:any` - Any data type
+
+  ## Example
+
+      defmodule MyNode do
+        use GitlockWorkflows.Runtime.Node
+        
+        @impl true
+        def metadata do
+          %{
+            id: "custom.mynode",
+            displayName: "My Custom Node",
+            group: "custom",
+            version: 1,
+            description: "Does something special",
+            inputs: [
+              %{name: "main", type: :any, required: true}
+            ],
+            outputs: [
+              %{name: "main", type: :any}
+            ],
+            parameters: [
+              %{
+                name: "option",
+                displayName: "Option",
+                type: "string",
+                default: "value"
+              }
+            ]
+          }
+        end
+        
+        @impl true
+        def execute(input_data, parameters, context) do
+          # Implementation
+          {:ok, %{"main" => result}}
+        end
+        
+        @impl true
+        def validate_parameters(parameters) do
+          # Validation logic
+          :ok
+        end
+      end
+
+  ## Registration
+
+  To register your node, use the Registry module:
+
+      GitlockWorkflows.Runtime.Registry.register_node(MyNode)
+  """
+
+  @type port_type ::
+          :string
+          | :number
+          | :boolean
+          | {:list, port_type()}
+          | {:map, port_type()}
+          | :any
+
+  @type port_definition :: %{
+          name: String.t(),
+          type: port_type(),
+          required: boolean(),
+          description: String.t() | nil
+        }
+
+  @type parameter_type ::
+          String.t()
+
+  @type parameter_definition :: %{
+          name: String.t(),
+          displayName: String.t(),
+          type: parameter_type(),
+          default: any(),
+          required: boolean(),
+          description: String.t() | nil,
+          options: [any()] | nil
+        }
+
+  @type node_metadata :: %{
+          id: String.t(),
+          displayName: String.t(),
+          group: String.t(),
+          version: integer(),
+          description: String.t(),
+          inputs: [port_definition()],
+          outputs: [port_definition()],
+          parameters: [parameter_definition()]
+        }
+
+  @type validation_error :: {atom(), String.t()}
+
+  # Behaviour callbacks
+  @callback metadata() :: node_metadata()
+  @callback execute(
+              input_data :: map(),
+              parameters :: map(),
+              context :: GitlockWorkflows.Runtime.Context.t()
+            ) ::
+              {:ok, output_data :: map()} | {:error, term()}
+  @callback validate_parameters(parameters :: map()) :: :ok | {:error, [validation_error()]}
+
+  # Optional callbacks
+  @callback reactor_options() :: keyword()
+
+  @optional_callbacks [reactor_options: 0]
+
+  @doc """
+  When used, provides common functionality for nodes and bridges to Reactor.Step.
+  """
+  defmacro __using__(_opts) do
+    quote do
+      @behaviour GitlockWorkflows.Runtime.Node
+      @behaviour Reactor.Step
+
+      @impl Reactor.Step
+      def run(arguments, context, options) do
+        # The parameters are stored in the current_step's context
+        step_params =
+          case Map.get(context, :current_step) do
+            %{context: %{parameters: params}} when is_map(params) ->
+              params
+
+            _ ->
+              %{}
+          end
+
+        # Convert arguments map to input data
+        input_data = Map.new(arguments)
+
+        # Call the node's execute function with proper parameters
+        case execute(input_data, step_params, context) do
+          {:ok, output} ->
+            {:ok, output}
+
+          {:error, reason} ->
+            {:error, reason}
+        end
+      end
+
+      @impl Reactor.Step
+      def compensate(_reason, _arguments, _context, _options) do
+        # Default compensation - nodes can override this
+        :ok
+      end
+
+      @impl Reactor.Step
+      def async?(_options), do: true
+
+      @impl Reactor.Step
+      def can?(_step, _capability), do: false
+
+      # Provide default reactor_options if not implemented
+      def reactor_options, do: []
+
+      # Make compensate and reactor_options overridable
+      defoverridable compensate: 4, reactor_options: 0, async?: 1, can?: 2
+    end
+  end
+
+  # Convenience functions that delegate to Registry
+  # These are kept for backward compatibility
+
+  @doc """
+  Gets a node module by its type ID.
+
+  Delegates to GitlockWorkflows.Runtime.Registry.get_node/1
+  """
+  @spec get_module(String.t()) :: {:ok, module()} | {:error, :not_found}
+  def get_module(node_type) do
+    GitlockWorkflows.Runtime.Registry.get_node(node_type)
+  end
+
+  @doc """
+  Gets metadata for a node by its ID.
+
+  Delegates to GitlockWorkflows.Runtime.Registry.get_metadata/1
+  """
+  @spec get_metadata(String.t()) :: {:ok, node_metadata()} | {:error, :not_found}
+  def get_metadata(node_id) do
+    GitlockWorkflows.Runtime.Registry.get_metadata(node_id)
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/code_age.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/code_age.ex
new file mode 100644
index 0000000..5d80db1
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/code_age.ex
@@ -0,0 +1,43 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.CodeAge do
+  @moduledoc "Analyzes how recently code was modified."
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Domain.Services.{CodeAgeAnalysis, FileHistoryService}
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.code_age",
+      displayName: "Code Age",
+      group: "analysis",
+      version: 1,
+      description: "Analyzes how recently code was modified",
+      inputs: [%{name: "commits", type: {:list, :map}, required: true}],
+      outputs: [%{name: "code_age", type: {:list, :map}}],
+      parameters: []
+    }
+  end
+
+  @impl true
+  def execute(input_data, _parameters, context) do
+    commits = input_data[:commits]
+    if is_nil(commits), do: throw({:error, "commits input is required"})
+
+    Executor.report_status(context, "Building file history...")
+    history = FileHistoryService.build_history(commits)
+    normalized = FileHistoryService.normalize_commits(commits, history)
+
+    Executor.report_status(context, "Calculating code age...")
+    results = CodeAgeAnalysis.calculate_code_age(normalized)
+
+    Executor.report_status(context, "Analyzed #{length(results)} files")
+    {:ok, %{code_age: results}}
+  catch
+    {:error, reason} -> {:error, reason}
+  end
+
+  @impl true
+  def validate_parameters(_parameters), do: :ok
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/complexity.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/complexity.ex
new file mode 100644
index 0000000..c8d09f3
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/complexity.ex
@@ -0,0 +1,137 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.Complexity do
+  @moduledoc """
+  Analysis node for computing cyclomatic complexity of repository files.
+
+  Uses `git ls-tree` to list files and `git show HEAD:<path>` to read content
+  from the git database. This works with both full clones and `--no-checkout`
+  clones (which only have the `.git` directory).
+
+  Accepts `repo_path` from the upstream Git Commits node so it analyzes the
+  same repository without requiring a separate parameter.
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Adapters.Complexity.DispatchAnalyzer
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.complexity",
+      displayName: "Complexity Analysis",
+      group: "analysis",
+      version: 1,
+      description: "Analyzes code complexity using the git database (works without checkout)",
+      inputs: [
+        %{
+          name: "repo_path",
+          type: :string,
+          required: true,
+          description: "Local path to the git repository (from Git Commits node)"
+        }
+      ],
+      outputs: [
+        %{
+          name: "complexity_map",
+          type: :map,
+          description: "Map of file paths to complexity metrics"
+        }
+      ],
+      parameters: []
+    }
+  end
+
+  @impl true
+  def execute(input_data, _parameters, context) do
+    # Prefer input port, fall back to execution context
+    repo_path = input_data[:repo_path] || context[:repo_path]
+
+    if is_nil(repo_path) or repo_path == "" do
+      {:error, "repo_path is required — configure a repository URL on the Git Log node"}
+    else
+      analyze_from_git(repo_path, context)
+    end
+  end
+
+  defp analyze_from_git(repo_path, context) do
+    Executor.report_status(context, "Listing repository files...")
+
+    supported_ext = DispatchAnalyzer.supported_extensions()
+
+    case list_tracked_files(repo_path) do
+      {:ok, all_files} ->
+        # Filter to files with supported extensions (skip "*" wildcard from MockAnalyzer)
+        real_ext = Enum.reject(supported_ext, &(&1 == "*"))
+
+        files =
+          Enum.filter(all_files, fn path ->
+            Path.extname(path) in real_ext
+          end)
+
+        Executor.report_status(context, "Analyzing #{length(files)} source files...")
+
+        complexity_map =
+          files
+          |> Task.async_stream(
+            fn file_path ->
+              case read_file_from_git(repo_path, file_path) do
+                {:ok, content} ->
+                  case DispatchAnalyzer.analyze_content(content, file_path) do
+                    {:ok, metrics} -> {file_path, metrics}
+                    {:error, _} -> nil
+                  end
+
+                {:error, _} ->
+                  nil
+              end
+            end,
+            max_concurrency: System.schedulers_online() * 2,
+            on_timeout: :kill_task
+          )
+          |> Enum.reduce(%{}, fn
+            {:ok, {path, metrics}}, acc -> Map.put(acc, path, metrics)
+            {:ok, nil}, acc -> acc
+            {:exit, _}, acc -> acc
+          end)
+
+        Executor.report_status(context, "Analyzed #{map_size(complexity_map)} files")
+        {:ok, %{complexity_map: complexity_map}}
+
+      {:error, reason} ->
+        {:error, "Failed to list files: #{reason}"}
+    end
+  end
+
+  # List all tracked files at HEAD using `git ls-tree`
+  defp list_tracked_files(repo_path) do
+    case System.cmd("git", ["ls-tree", "-r", "--name-only", "HEAD"],
+           cd: repo_path,
+           stderr_to_stdout: true
+         ) do
+      {output, 0} ->
+        files =
+          output
+          |> String.split("\n", trim: true)
+
+        {:ok, files}
+
+      {error, code} ->
+        {:error, "git ls-tree failed (#{code}): #{String.trim(error)}"}
+    end
+  end
+
+  # Read a file's content at HEAD from the git database
+  defp read_file_from_git(repo_path, file_path) do
+    case System.cmd("git", ["show", "HEAD:#{file_path}"],
+           cd: repo_path,
+           stderr_to_stdout: true
+         ) do
+      {content, 0} -> {:ok, content}
+      {error, _code} -> {:error, String.trim(error)}
+    end
+  end
+
+  @impl true
+  def validate_parameters(_parameters), do: :ok
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/complexity_trend.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/complexity_trend.ex
new file mode 100644
index 0000000..70e9b7f
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/complexity_trend.ex
@@ -0,0 +1,136 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.ComplexityTrend do
+  @moduledoc """
+  Analysis node for detecting complexity trends in hotspot files.
+
+  This is the "X-Ray" analysis — it reveals whether hotspot files are
+  getting more complex over time, stable, or improving. It samples
+  historical file content at monthly intervals and runs complexity
+  analysis on each snapshot.
+
+  Requires `repo_path` as a parameter (injected by the compiler) since
+  it needs to run `git show` to retrieve historical file content.
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Domain.Services.ComplexityTrendAnalysis
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.complexity_trend",
+      displayName: "Complexity Trends",
+      group: "analysis",
+      version: 1,
+      description: "X-ray hotspot files to reveal complexity trajectories over time",
+      inputs: [
+        %{
+          name: "commits",
+          type: {:list, :map},
+          required: true,
+          description: "Git commits data from trigger"
+        }
+      ],
+      outputs: [
+        %{
+          name: "complexity_trends",
+          type: {:list, :map},
+          description: "Complexity trend for each hotspot file"
+        }
+      ],
+      parameters: [
+        %{
+          name: "repo_path",
+          displayName: "Repository Path",
+          type: "string",
+          default: "",
+          required: true,
+          description: "Path to git repository (injected automatically)"
+        },
+        %{
+          name: "max_files",
+          displayName: "Max Files",
+          type: "number",
+          default: "15",
+          required: false,
+          description: "Number of top hotspot files to analyze"
+        },
+        %{
+          name: "interval_days",
+          displayName: "Sample Interval (days)",
+          type: "number",
+          default: "30",
+          required: false,
+          description: "Days between complexity sample points"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, context) do
+    commits = input_data[:commits]
+
+    repo_path =
+      Map.get(parameters, "repo_path") || Map.get(parameters, :repo_path) || ""
+
+    if is_nil(commits) or commits == [] do
+      {:error, "commits input is required"}
+    else
+      if repo_path == "" do
+        {:error, "repo_path parameter is required for complexity trend analysis"}
+      else
+        max_files = parse_int(parameters, "max_files", 15)
+        interval_days = parse_int(parameters, "interval_days", 30)
+
+        progress_fn = fn message ->
+          Executor.report_status(context, message)
+        end
+
+        Executor.report_status(context, "Starting complexity trend analysis...")
+
+        trends =
+          ComplexityTrendAnalysis.analyze(commits, repo_path,
+            max_files: max_files,
+            interval_days: interval_days,
+            progress_fn: progress_fn
+          )
+
+        rising = Enum.count(trends, &(&1.direction == :rising))
+        declining = Enum.count(trends, &(&1.direction == :declining))
+
+        Executor.report_status(
+          context,
+          "Found #{length(trends)} trends: #{rising} rising, #{declining} declining"
+        )
+
+        {:ok, %{complexity_trends: trends}}
+      end
+    end
+  end
+
+  @impl true
+  def validate_parameters(_parameters), do: :ok
+
+  defp parse_int(params, key, default) do
+    val = Map.get(params, key) || Map.get(params, String.to_atom(key))
+
+    case val do
+      nil ->
+        default
+
+      v when is_integer(v) ->
+        v
+
+      v when is_binary(v) ->
+        case Integer.parse(v) do
+          {n, _} -> n
+          :error -> default
+        end
+
+      _ ->
+        default
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/coupled_hotspot.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/coupled_hotspot.ex
new file mode 100644
index 0000000..56683fb
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/coupled_hotspot.ex
@@ -0,0 +1,147 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.CoupledHotspot do
+  @moduledoc "Finds hotspots that are temporally coupled."
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Domain.Services.{CoupledHotspotAnalysis, FileHistoryService}
+  alias GitlockCore.Adapters.Complexity.DispatchAnalyzer
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.coupled_hotspot",
+      displayName: "Coupled Hotspots",
+      group: "analysis",
+      version: 1,
+      description: "Finds hotspots that are temporally coupled",
+      inputs: [
+        %{name: "commits", type: {:list, :map}, required: true},
+        %{
+          name: "repo_path",
+          type: :string,
+          required: false,
+          description:
+            "Repository path (used to auto-compute complexity if complexity_map is not provided)"
+        },
+        %{name: "complexity_map", type: {:list, :map}, required: false}
+      ],
+      outputs: [%{name: "coupled_hotspots", type: {:list, :map}}],
+      parameters: []
+    }
+  end
+
+  @impl true
+  def execute(input_data, _parameters, context) do
+    commits = input_data[:commits]
+    repo_path = input_data[:repo_path] || resolve_repo_path(context[:repo_path])
+    explicit_complexity_map = input_data[:complexity_map]
+
+    if is_nil(commits), do: throw({:error, "commits input is required"})
+
+    complexity_map = resolve_complexity_map(explicit_complexity_map, repo_path, context)
+
+    Executor.report_status(context, "Building file history...")
+    history = FileHistoryService.build_history(commits)
+    normalized = FileHistoryService.normalize_commits(commits, history)
+
+    Executor.report_status(context, "Detecting coupled hotspots...")
+    results = CoupledHotspotAnalysis.detect_combined(normalized, complexity_map)
+
+    Executor.report_status(context, "Found #{length(results)} coupled hotspots")
+    {:ok, %{coupled_hotspots: results}}
+  catch
+    {:error, reason} -> {:error, reason}
+  end
+
+  defp resolve_complexity_map(map, _repo_path, _context)
+       when is_map(map) and map_size(map) > 0,
+       do: map
+
+  defp resolve_complexity_map(_nil_or_empty, repo_path, context)
+       when is_binary(repo_path) and repo_path != "" do
+    Executor.report_status(context, "Computing complexity metrics...")
+    compute_complexity_from_git(repo_path, context)
+  end
+
+  defp resolve_complexity_map(_, _, _), do: %{}
+
+  defp compute_complexity_from_git(repo_path, context) do
+    supported_ext =
+      DispatchAnalyzer.supported_extensions()
+      |> Enum.reject(&(&1 == "*"))
+
+    case list_tracked_files(repo_path) do
+      {:ok, all_files} ->
+        files = Enum.filter(all_files, fn path -> Path.extname(path) in supported_ext end)
+        Executor.report_status(context, "Analyzing complexity of #{length(files)} files...")
+
+        files
+        |> Task.async_stream(
+          fn file_path ->
+            with {:ok, content} <- read_file_from_git(repo_path, file_path),
+                 {:ok, metrics} <- DispatchAnalyzer.analyze_content(content, file_path) do
+              {file_path, metrics}
+            else
+              _ -> nil
+            end
+          end,
+          max_concurrency: System.schedulers_online() * 2,
+          on_timeout: :kill_task
+        )
+        |> Enum.reduce(%{}, fn
+          {:ok, {path, metrics}}, acc -> Map.put(acc, path, metrics)
+          _, acc -> acc
+        end)
+
+      {:error, reason} ->
+        Logger.warning("Could not list repo files for complexity: #{reason}")
+        %{}
+    end
+  end
+
+  defp list_tracked_files(repo_path) do
+    case System.cmd("git", ["ls-tree", "-r", "--name-only", "HEAD"],
+           cd: repo_path,
+           stderr_to_stdout: true
+         ) do
+      {output, 0} -> {:ok, String.split(output, "\n", trim: true)}
+      {error, code} -> {:error, "git ls-tree failed (#{code}): #{String.trim(error)}"}
+    end
+  end
+
+  defp read_file_from_git(repo_path, file_path) do
+    case System.cmd("git", ["show", "HEAD:#{file_path}"], cd: repo_path, stderr_to_stdout: true) do
+      {content, 0} -> {:ok, content}
+      {error, _code} -> {:error, String.trim(error)}
+    end
+  end
+
+  defp resolve_repo_path(nil), do: nil
+  defp resolve_repo_path(""), do: nil
+
+  defp resolve_repo_path(source) do
+    if String.starts_with?(source, "https://") or
+         String.starts_with?(source, "http://") or
+         String.starts_with?(source, "git@") or
+         String.starts_with?(source, "ssh://") do
+      hash =
+        :crypto.hash(:sha256, source)
+        |> Base.url_encode64(padding: false)
+        |> String.slice(0..11)
+
+      repo_name =
+        source
+        |> String.split("/")
+        |> List.last()
+        |> String.replace(~r/\.git$/, "")
+
+      Path.join([System.tmp_dir!(), "gitlock", "clones", "#{repo_name}_#{hash}"])
+    else
+      source
+    end
+  end
+
+  @impl true
+  def validate_parameters(_parameters), do: :ok
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/coupling.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/coupling.ex
new file mode 100644
index 0000000..ebc4627
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/coupling.ex
@@ -0,0 +1,61 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.Coupling do
+  @moduledoc "Detects files that change together (temporal coupling)."
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Domain.Services.{CouplingDetection, FileHistoryService}
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.coupling",
+      displayName: "Coupling Detection",
+      group: "analysis",
+      version: 1,
+      description: "Detects files that change together (temporal coupling)",
+      inputs: [%{name: "commits", type: {:list, :map}, required: true}],
+      outputs: [%{name: "couplings", type: {:list, :map}}],
+      parameters: [
+        %{
+          name: "min_coupling",
+          displayName: "Min coupling score",
+          type: "number",
+          default: 1.0,
+          required: false
+        },
+        %{
+          name: "min_windows",
+          displayName: "Min time windows",
+          type: "number",
+          default: 5,
+          required: false
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, context) do
+    commits = input_data[:commits]
+    if is_nil(commits), do: throw({:error, "commits input is required"})
+
+    min_coupling = Map.get(parameters, "min_coupling", 1.0)
+    min_windows = Map.get(parameters, "min_windows", 5)
+
+    Executor.report_status(context, "Building file history...")
+    history = FileHistoryService.build_history(commits)
+    normalized = FileHistoryService.normalize_commits(commits, history)
+
+    Executor.report_status(context, "Detecting temporal couplings...")
+    results = CouplingDetection.detect_couplings(normalized, min_coupling, min_windows)
+
+    Executor.report_status(context, "Found #{length(results)} couplings")
+    {:ok, %{couplings: results}}
+  catch
+    {:error, reason} -> {:error, reason}
+  end
+
+  @impl true
+  def validate_parameters(_parameters), do: :ok
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/hotspot.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/hotspot.ex
new file mode 100644
index 0000000..0410a9e
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/hotspot.ex
@@ -0,0 +1,183 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.Hotspot do
+  @moduledoc """
+  Analysis node for detecting code hotspots in a repository.
+
+  This node identifies files that are:
+  - Frequently changed (high revision count)  
+  - Complex (high cyclomatic complexity)
+  - Large (high lines of code)
+  - High risk (combination of above factors)
+
+  When a `complexity_map` input is connected, it uses that directly.
+  Otherwise, if `repo_path` is available, it automatically runs complexity
+  analysis so users don't have to wire up a separate Complexity node.
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Domain.Services.HotspotDetection
+  alias GitlockCore.Adapters.Complexity.DispatchAnalyzer
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.hotspot",
+      displayName: "Hotspot Analysis",
+      group: "analysis",
+      version: 1,
+      description: "Analyzes code hotspots by examining change frequency and complexity",
+      inputs: [
+        %{
+          name: "commits",
+          type: {:list, :map},
+          required: true,
+          description: "Git commits data from trigger"
+        },
+        %{
+          name: "repo_path",
+          type: :string,
+          required: false,
+          description:
+            "Repository path (used to auto-compute complexity if complexity_map is not provided)"
+        },
+        %{
+          name: "complexity_map",
+          type: :map,
+          required: false,
+          description:
+            "Pre-computed complexity map (if not provided, will be computed automatically from repo_path)"
+        }
+      ],
+      outputs: [
+        %{
+          name: "hotspots",
+          type: {:list, :map},
+          description: "List of hotspot analysis results"
+        }
+      ],
+      parameters: []
+    }
+  end
+
+  @impl true
+  def execute(input_data, _parameters, context) do
+    commits = input_data[:commits]
+    repo_path = input_data[:repo_path] || resolve_repo_path(context[:repo_path])
+    explicit_complexity_map = input_data[:complexity_map]
+
+    if is_nil(commits) do
+      {:error, "commits input is required"}
+    else
+      complexity_map = resolve_complexity_map(explicit_complexity_map, repo_path, context)
+
+      Executor.report_status(context, "Analyzing #{length(commits)} commits...")
+      hotspots = HotspotDetection.detect_hotspots(commits, complexity_map)
+      Executor.report_status(context, "Found #{length(hotspots)} hotspots")
+
+      {:ok, %{hotspots: hotspots}}
+    end
+  end
+
+  # Use explicit complexity_map if provided
+  defp resolve_complexity_map(map, _repo_path, _context) when is_map(map) and map_size(map) > 0 do
+    map
+  end
+
+  # Otherwise, auto-compute from repo_path
+  defp resolve_complexity_map(_nil_or_empty, repo_path, context)
+       when is_binary(repo_path) and repo_path != "" do
+    Executor.report_status(context, "Computing complexity metrics...")
+    compute_complexity_from_git(repo_path, context)
+  end
+
+  # No complexity data available at all
+  defp resolve_complexity_map(_, _, _), do: %{}
+
+  defp compute_complexity_from_git(repo_path, context) do
+    supported_ext =
+      DispatchAnalyzer.supported_extensions()
+      |> Enum.reject(&(&1 == "*"))
+
+    case list_tracked_files(repo_path) do
+      {:ok, all_files} ->
+        files = Enum.filter(all_files, fn path -> Path.extname(path) in supported_ext end)
+        Executor.report_status(context, "Analyzing complexity of #{length(files)} files...")
+
+        files
+        |> Task.async_stream(
+          fn file_path ->
+            with {:ok, content} <- read_file_from_git(repo_path, file_path),
+                 {:ok, metrics} <- DispatchAnalyzer.analyze_content(content, file_path) do
+              {file_path, metrics}
+            else
+              _ -> nil
+            end
+          end,
+          max_concurrency: System.schedulers_online() * 2,
+          on_timeout: :kill_task
+        )
+        |> Enum.reduce(%{}, fn
+          {:ok, {path, metrics}}, acc -> Map.put(acc, path, metrics)
+          _, acc -> acc
+        end)
+
+      {:error, reason} ->
+        Logger.warning("Could not list repo files for complexity: #{reason}")
+        %{}
+    end
+  end
+
+  defp list_tracked_files(repo_path) do
+    case System.cmd("git", ["ls-tree", "-r", "--name-only", "HEAD"],
+           cd: repo_path,
+           stderr_to_stdout: true
+         ) do
+      {output, 0} -> {:ok, String.split(output, "\n", trim: true)}
+      {error, code} -> {:error, "git ls-tree failed (#{code}): #{String.trim(error)}"}
+    end
+  end
+
+  defp read_file_from_git(repo_path, file_path) do
+    case System.cmd("git", ["show", "HEAD:#{file_path}"],
+           cd: repo_path,
+           stderr_to_stdout: true
+         ) do
+      {content, 0} -> {:ok, content}
+      {error, _code} -> {:error, String.trim(error)}
+    end
+  end
+
+  # Resolve a repo source to a local path where git commands can run.
+  # For remote URLs, this is the cached clone directory.
+  # For local paths, return as-is.
+  defp resolve_repo_path(nil), do: nil
+  defp resolve_repo_path(""), do: nil
+
+  defp resolve_repo_path(source) do
+    if String.starts_with?(source, "https://") or
+         String.starts_with?(source, "http://") or
+         String.starts_with?(source, "git@") or
+         String.starts_with?(source, "ssh://") do
+      hash =
+        :crypto.hash(:sha256, source)
+        |> Base.url_encode64(padding: false)
+        |> String.slice(0..11)
+
+      repo_name =
+        source
+        |> String.split("/")
+        |> List.last()
+        |> String.replace(~r/\.git$/, "")
+
+      Path.join([System.tmp_dir!(), "gitlock", "clones", "#{repo_name}_#{hash}"])
+    else
+      source
+    end
+  end
+
+  @impl true
+  def validate_parameters(_parameters) do
+    :ok
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/knowledge_silo.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/knowledge_silo.ex
new file mode 100644
index 0000000..2a6a5c7
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/knowledge_silo.ex
@@ -0,0 +1,43 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.KnowledgeSilo do
+  @moduledoc "Identifies concentrated code ownership patterns."
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Domain.Services.{KnowledgeSiloDetection, FileHistoryService}
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.knowledge_silo",
+      displayName: "Knowledge Silos",
+      group: "analysis",
+      version: 1,
+      description: "Identifies concentrated code ownership patterns",
+      inputs: [%{name: "commits", type: {:list, :map}, required: true}],
+      outputs: [%{name: "knowledge_silos", type: {:list, :map}}],
+      parameters: []
+    }
+  end
+
+  @impl true
+  def execute(input_data, _parameters, context) do
+    commits = input_data[:commits]
+    if is_nil(commits), do: throw({:error, "commits input is required"})
+
+    Executor.report_status(context, "Building file history...")
+    history = FileHistoryService.build_history(commits)
+    normalized = FileHistoryService.normalize_commits(commits, history)
+
+    Executor.report_status(context, "Detecting knowledge silos...")
+    results = KnowledgeSiloDetection.detect_knowledge_silos(normalized)
+
+    Executor.report_status(context, "Found #{length(results)} silos")
+    {:ok, %{knowledge_silos: results}}
+  catch
+    {:error, reason} -> {:error, reason}
+  end
+
+  @impl true
+  def validate_parameters(_parameters), do: :ok
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/summary.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/summary.ex
new file mode 100644
index 0000000..ed522bc
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/analysis/summary.ex
@@ -0,0 +1,41 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Analysis.Summary do
+  @moduledoc "Generates a summary of repository activity."
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockCore.Domain.Services.{Summary, FileHistoryService}
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.analysis.summary",
+      displayName: "Summary",
+      group: "analysis",
+      version: 1,
+      description: "Generates a summary of repository activity",
+      inputs: [%{name: "commits", type: {:list, :map}, required: true}],
+      outputs: [%{name: "summary", type: :map}],
+      parameters: []
+    }
+  end
+
+  @impl true
+  def execute(input_data, _parameters, context) do
+    commits = input_data[:commits]
+    if is_nil(commits), do: throw({:error, "commits input is required"})
+
+    Executor.report_status(context, "Summarizing #{length(commits)} commits...")
+    history = FileHistoryService.build_history(commits)
+    normalized = FileHistoryService.normalize_commits(commits, history)
+    results = Summary.summarize(normalized)
+
+    Executor.report_status(context, "Summary complete")
+    {:ok, %{summary: results}}
+  catch
+    {:error, reason} -> {:error, reason}
+  end
+
+  @impl true
+  def validate_parameters(_parameters), do: :ok
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/aggregate.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/aggregate.ex
new file mode 100644
index 0000000..9a46306
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/aggregate.ex
@@ -0,0 +1,121 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.Aggregate do
+  @moduledoc """
+  Computes aggregate statistics over a list of items.
+
+  Outputs a summary map with computed values. Useful for dashboards
+  and reports that need totals, averages, or distributions.
+
+  ## Examples
+
+  Count and sum revisions across hotspots:
+
+      parameters: %{"operations" => "count,sum:revisions,avg:risk_score,max:complexity"}
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.aggregate",
+      displayName: "Aggregate",
+      group: "logic",
+      version: 1,
+      description: "Computes statistics: count, sum, average, min, max over items",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [%{name: "result", type: :any}],
+      parameters: [
+        %{
+          name: "operations",
+          displayName: "Operations",
+          type: "string",
+          required: true,
+          default: "count",
+          placeholder: "count,sum:revisions,avg:risk_score,max:complexity",
+          description: "Comma-separated: count, sum:field, avg:field, min:field, max:field"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    ops_string = Map.get(parameters, "operations", "count")
+
+    ops = parse_operations(ops_string)
+    result = compute(items, ops)
+
+    Logger.info("Aggregate: #{length(ops)} operations over #{length(items)} items")
+    {:ok, %{result: result}}
+  end
+
+  @impl true
+  def validate_parameters(_), do: :ok
+
+  defp parse_operations(ops_string) do
+    ops_string
+    |> String.split(",", trim: true)
+    |> Enum.map(&String.trim/1)
+    |> Enum.map(fn op ->
+      case String.split(op, ":", parts: 2) do
+        [func, field] -> {func, field}
+        [func] -> {func, nil}
+      end
+    end)
+  end
+
+  defp compute(items, ops) do
+    Enum.reduce(ops, %{}, fn {func, field}, acc ->
+      key = if field, do: "#{func}_#{field}", else: func
+      value = run_op(func, field, items)
+      Map.put(acc, key, value)
+    end)
+  end
+
+  defp run_op("count", _field, items), do: length(items)
+
+  defp run_op("sum", field, items) do
+    items |> Enum.map(&get_number(&1, field)) |> Enum.sum()
+  end
+
+  defp run_op("avg", field, items) do
+    values = Enum.map(items, &get_number(&1, field))
+    if values == [], do: 0, else: Enum.sum(values) / length(values)
+  end
+
+  defp run_op("min", field, items) do
+    items |> Enum.map(&get_number(&1, field)) |> Enum.min(fn -> 0 end)
+  end
+
+  defp run_op("max", field, items) do
+    items |> Enum.map(&get_number(&1, field)) |> Enum.max(fn -> 0 end)
+  end
+
+  defp run_op(unknown, _, _), do: {:error, "unknown operation: #{unknown}"}
+
+  defp get_number(item, field) when is_map(item) do
+    val = Map.get(item, field) || Map.get(item, String.to_atom(field))
+    to_number(val)
+  end
+
+  defp get_number(_, _), do: 0
+
+  defp to_number(v) when is_number(v), do: v
+
+  defp to_number(v) when is_binary(v) do
+    case Float.parse(v) do
+      {n, _} -> n
+      :error -> 0
+    end
+  end
+
+  defp to_number(_), do: 0
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) -> list
+      _ -> input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/filter.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/filter.ex
new file mode 100644
index 0000000..f590ca1
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/filter.ex
@@ -0,0 +1,152 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.Filter do
+  @moduledoc """
+  Filters items based on a field condition.
+
+  Like n8n's Filter node — keeps items where a field matches a condition,
+  and sends rejected items to a separate output port.
+
+  ## Examples
+
+  Filter hotspots to only high-risk:
+
+      parameters: %{"field" => "risk_factor", "operator" => "eq", "value" => "high"}
+
+  Filter files with more than 10 revisions:
+
+      parameters: %{"field" => "revisions", "operator" => "gt", "value" => "10"}
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @operators ~w(eq neq gt lt gte lte contains not_contains)
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.filter",
+      displayName: "Filter",
+      group: "logic",
+      version: 1,
+      description: "Keeps items matching a condition, sends rejected items to a separate output",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [
+        %{name: "kept", type: :any, description: "Items matching the condition"},
+        %{name: "rejected", type: :any, description: "Items not matching"}
+      ],
+      parameters: [
+        %{
+          name: "field",
+          displayName: "Field",
+          type: "string",
+          required: true,
+          description: "Field name to check (e.g., 'risk_factor', 'revisions')"
+        },
+        %{
+          name: "operator",
+          displayName: "Operator",
+          type: "select",
+          required: true,
+          default: "eq",
+          options: Enum.map(@operators, &%{value: &1, label: format_op(&1)}),
+          description: "Comparison operator"
+        },
+        %{
+          name: "value",
+          displayName: "Value",
+          type: "string",
+          required: true,
+          description: "Value to compare against"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    field = Map.get(parameters, "field", "")
+    operator = Map.get(parameters, "operator", "eq")
+    value = Map.get(parameters, "value", "")
+
+    if field == "" do
+      {:error, "field parameter is required"}
+    else
+      {kept, rejected} = Enum.split_with(items, &matches?(&1, field, operator, value))
+      Logger.info("Filter: #{length(kept)} kept, #{length(rejected)} rejected")
+      {:ok, %{kept: kept, rejected: rejected}}
+    end
+  end
+
+  @impl true
+  def validate_parameters(params) do
+    cond do
+      blank?(params, "field") -> {:error, [{:missing_required_parameter, "field"}]}
+      blank?(params, "operator") -> {:error, [{:missing_required_parameter, "operator"}]}
+      true -> :ok
+    end
+  end
+
+  defp matches?(item, field, operator, value) when is_map(item) do
+    item_value = get_field(item, field)
+    compare(item_value, operator, coerce(value, item_value))
+  end
+
+  defp matches?(_, _, _, _), do: false
+
+  defp compare(a, "eq", b), do: a == b
+  defp compare(a, "neq", b), do: a != b
+  defp compare(a, "gt", b) when is_number(a) and is_number(b), do: a > b
+  defp compare(a, "lt", b) when is_number(a) and is_number(b), do: a < b
+  defp compare(a, "gte", b) when is_number(a) and is_number(b), do: a >= b
+  defp compare(a, "lte", b) when is_number(a) and is_number(b), do: a <= b
+  defp compare(a, "contains", b) when is_binary(a) and is_binary(b), do: String.contains?(a, b)
+
+  defp compare(a, "not_contains", b) when is_binary(a) and is_binary(b),
+    do: not String.contains?(a, b)
+
+  defp compare(_, _, _), do: false
+
+  defp coerce(value, reference) when is_number(reference) do
+    case Float.parse(value) do
+      {num, _} -> num
+      :error -> value
+    end
+  end
+
+  defp coerce(value, reference) when is_atom(reference) and not is_nil(reference) do
+    try do
+      String.to_existing_atom(value)
+    rescue
+      _ -> value
+    end
+  end
+
+  defp coerce(value, _), do: value
+
+  defp get_field(item, field) do
+    Map.get(item, field) || Map.get(item, String.to_atom(field))
+  end
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) ->
+        list
+
+      _ ->
+        # Try to find the first list value in input data
+        input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+
+  defp blank?(params, key), do: (Map.get(params, key) || "") == ""
+
+  defp format_op("eq"), do: "Equals"
+  defp format_op("neq"), do: "Not Equals"
+  defp format_op("gt"), do: "Greater Than"
+  defp format_op("lt"), do: "Less Than"
+  defp format_op("gte"), do: "Greater or Equal"
+  defp format_op("lte"), do: "Less or Equal"
+  defp format_op("contains"), do: "Contains"
+  defp format_op("not_contains"), do: "Not Contains"
+  defp format_op(other), do: other
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/group_by.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/group_by.ex
new file mode 100644
index 0000000..df00578
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/group_by.ex
@@ -0,0 +1,86 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.GroupBy do
+  @moduledoc """
+  Groups items by a field value.
+
+  Outputs a map where keys are field values and values are lists of matching items.
+  Also outputs a flat list of group summaries for downstream processing.
+
+  ## Examples
+
+  Group hotspots by risk_factor:
+
+      parameters: %{"field" => "risk_factor"}
+      # groups: %{"high" => [...], "medium" => [...], "low" => [...]}
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.group_by",
+      displayName: "Group By",
+      group: "logic",
+      version: 1,
+      description: "Groups items by a field value",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [
+        %{name: "groups", type: :any, description: "Map of group_value → items"},
+        %{name: "items", type: :any, description: "Flat list of group summaries"}
+      ],
+      parameters: [
+        %{
+          name: "field",
+          displayName: "Group By",
+          type: "string",
+          required: true,
+          description: "Field name to group by"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    field = Map.get(parameters, "field", "")
+
+    if field == "" do
+      {:error, "field parameter is required"}
+    else
+      groups = Enum.group_by(items, &get_field(&1, field))
+
+      summaries =
+        Enum.map(groups, fn {key, group_items} ->
+          %{group: key, count: length(group_items), items: group_items}
+        end)
+        |> Enum.sort_by(& &1.count, :desc)
+
+      Logger.info("Group by '#{field}': #{map_size(groups)} groups from #{length(items)} items")
+      {:ok, %{groups: groups, items: summaries}}
+    end
+  end
+
+  @impl true
+  def validate_parameters(params) do
+    if (Map.get(params, "field") || "") == "" do
+      {:error, [{:missing_required_parameter, "field"}]}
+    else
+      :ok
+    end
+  end
+
+  defp get_field(item, field) when is_map(item) do
+    val = Map.get(item, field) || Map.get(item, String.to_atom(field))
+    to_string(val || "unknown")
+  end
+
+  defp get_field(_, _), do: "unknown"
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) -> list
+      _ -> input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/if.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/if.ex
new file mode 100644
index 0000000..18da35d
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/if.ex
@@ -0,0 +1,157 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.If do
+  @moduledoc """
+  Conditional branch — splits items into two output ports based on a condition.
+
+  Like n8n's IF node. Each item is evaluated against the condition and routed
+  to either the `true` or `false` output port. Downstream nodes connected to
+  each port receive only the matching items.
+
+  ## Examples
+
+  Split hotspots into high-risk and low-risk:
+
+      parameters: %{"field" => "risk_factor", "operator" => "eq", "value" => "high"}
+      # true port: items where risk_factor == "high"
+      # false port: items where risk_factor != "high"
+
+  Branch on revision count threshold:
+
+      parameters: %{"field" => "revisions", "operator" => "gte", "value" => "50"}
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @operators ~w(eq neq gt lt gte lte contains not_contains is_empty is_not_empty)
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.if",
+      displayName: "IF",
+      group: "logic",
+      version: 1,
+      description: "Routes items to 'true' or 'false' output based on a condition",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [
+        %{name: "true", type: :any, description: "Items matching the condition"},
+        %{name: "false", type: :any, description: "Items not matching"}
+      ],
+      parameters: [
+        %{
+          name: "field",
+          displayName: "Field",
+          type: "string",
+          required: true,
+          description: "Field name to evaluate"
+        },
+        %{
+          name: "operator",
+          displayName: "Operator",
+          type: "select",
+          required: true,
+          default: "eq",
+          options: Enum.map(@operators, &%{value: &1, label: format_op(&1)}),
+          description: "Comparison operator"
+        },
+        %{
+          name: "value",
+          displayName: "Value",
+          type: "string",
+          required: false,
+          default: "",
+          description: "Value to compare against (not needed for is_empty/is_not_empty)"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    field = Map.get(parameters, "field", "")
+    operator = Map.get(parameters, "operator", "eq")
+    value = Map.get(parameters, "value", "")
+
+    if field == "" do
+      {:error, "field parameter is required"}
+    else
+      {true_items, false_items} = Enum.split_with(items, &matches?(&1, field, operator, value))
+      Logger.info("IF: #{length(true_items)} true, #{length(false_items)} false")
+      {:ok, %{true: true_items, false: false_items}}
+    end
+  end
+
+  @impl true
+  def validate_parameters(params) do
+    if (Map.get(params, "field") || "") == "" do
+      {:error, [{:missing_required_parameter, "field"}]}
+    else
+      :ok
+    end
+  end
+
+  defp matches?(item, field, operator, value) when is_map(item) do
+    item_value = get_field(item, field)
+    compare(item_value, operator, coerce(value, item_value))
+  end
+
+  defp matches?(_, _, _, _), do: false
+
+  defp compare(a, "eq", b), do: a == b
+  defp compare(a, "neq", b), do: a != b
+  defp compare(a, "gt", b) when is_number(a) and is_number(b), do: a > b
+  defp compare(a, "lt", b) when is_number(a) and is_number(b), do: a < b
+  defp compare(a, "gte", b) when is_number(a) and is_number(b), do: a >= b
+  defp compare(a, "lte", b) when is_number(a) and is_number(b), do: a <= b
+  defp compare(a, "contains", b) when is_binary(a) and is_binary(b), do: String.contains?(a, b)
+
+  defp compare(a, "not_contains", b) when is_binary(a) and is_binary(b),
+    do: not String.contains?(a, b)
+
+  defp compare(nil, "is_empty", _), do: true
+  defp compare("", "is_empty", _), do: true
+  defp compare([], "is_empty", _), do: true
+  defp compare(_, "is_empty", _), do: false
+  defp compare(v, "is_not_empty", _), do: not compare(v, "is_empty", nil)
+  defp compare(_, _, _), do: false
+
+  defp coerce(value, reference) when is_number(reference) do
+    case Float.parse(value) do
+      {num, _} -> num
+      :error -> value
+    end
+  end
+
+  defp coerce(value, reference) when is_atom(reference) and not is_nil(reference) do
+    try do
+      String.to_existing_atom(value)
+    rescue
+      _ -> value
+    end
+  end
+
+  defp coerce(value, _), do: value
+
+  defp get_field(item, field) do
+    Map.get(item, field) || Map.get(item, String.to_atom(field))
+  end
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) -> list
+      _ -> input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+
+  defp format_op("eq"), do: "Equals"
+  defp format_op("neq"), do: "Not Equals"
+  defp format_op("gt"), do: "Greater Than"
+  defp format_op("lt"), do: "Less Than"
+  defp format_op("gte"), do: "≥"
+  defp format_op("lte"), do: "≤"
+  defp format_op("contains"), do: "Contains"
+  defp format_op("not_contains"), do: "Not Contains"
+  defp format_op("is_empty"), do: "Is Empty"
+  defp format_op("is_not_empty"), do: "Is Not Empty"
+  defp format_op(other), do: other
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/limit.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/limit.ex
new file mode 100644
index 0000000..2cdadc4
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/limit.ex
@@ -0,0 +1,87 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.Limit do
+  @moduledoc """
+  Takes the first or last N items from a list.
+
+  ## Examples
+
+  Top 20 hotspots:
+
+      parameters: %{"count" => 20, "from" => "start"}
+
+  Bottom 5 by risk:
+
+      parameters: %{"count" => 5, "from" => "end"}
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.limit",
+      displayName: "Limit",
+      group: "logic",
+      version: 1,
+      description: "Takes the first or last N items",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [%{name: "items", type: :any}],
+      parameters: [
+        %{
+          name: "count",
+          displayName: "Count",
+          type: "number",
+          required: true,
+          default: 10,
+          description: "Number of items to keep"
+        },
+        %{
+          name: "from",
+          displayName: "From",
+          type: "select",
+          required: false,
+          default: "start",
+          options: [%{value: "start", label: "First N"}, %{value: "end", label: "Last N"}],
+          description: "Take from start or end of list"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    count = to_int(Map.get(parameters, "count", 10))
+    from = Map.get(parameters, "from", "start")
+
+    limited =
+      case from do
+        "end" -> Enum.take(items, -count)
+        _ -> Enum.take(items, count)
+      end
+
+    Logger.info("Limit: #{length(limited)} of #{length(items)} items (#{from})")
+    {:ok, %{items: limited}}
+  end
+
+  @impl true
+  def validate_parameters(_), do: :ok
+
+  defp to_int(v) when is_integer(v), do: v
+  defp to_int(v) when is_float(v), do: round(v)
+
+  defp to_int(v) when is_binary(v) do
+    case Integer.parse(v) do
+      {n, _} -> n
+      :error -> 10
+    end
+  end
+
+  defp to_int(_), do: 10
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) -> list
+      _ -> input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/merge.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/merge.ex
new file mode 100644
index 0000000..276d254
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/merge.ex
@@ -0,0 +1,71 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.Merge do
+  @moduledoc """
+  Combines items from two input sources.
+
+  ## Modes
+
+  - `append` — Concatenate both lists
+  - `interleave` — Alternate items from each list
+  - `keep_a` — Keep only items_a (pass-through, useful after IF branches)
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.merge",
+      displayName: "Merge",
+      group: "logic",
+      version: 1,
+      description: "Combines items from two inputs into one output",
+      inputs: [
+        %{name: "items_a", type: :any, required: true, description: "First set of items"},
+        %{name: "items_b", type: :any, required: false, description: "Second set of items"}
+      ],
+      outputs: [%{name: "items", type: :any}],
+      parameters: [
+        %{
+          name: "mode",
+          displayName: "Mode",
+          type: "select",
+          required: false,
+          default: "append",
+          options: [
+            %{value: "append", label: "Append (A then B)"},
+            %{value: "interleave", label: "Interleave (alternate)"},
+            %{value: "keep_a", label: "Keep A only"}
+          ],
+          description: "How to combine the two inputs"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items_a = to_list(Map.get(input_data, :items_a))
+    items_b = to_list(Map.get(input_data, :items_b))
+    mode = Map.get(parameters, "mode", "append")
+
+    merged =
+      case mode do
+        "interleave" -> interleave(items_a, items_b)
+        "keep_a" -> items_a
+        _ -> items_a ++ items_b
+      end
+
+    Logger.info("Merge (#{mode}): #{length(items_a)} + #{length(items_b)} → #{length(merged)}")
+    {:ok, %{items: merged}}
+  end
+
+  @impl true
+  def validate_parameters(_), do: :ok
+
+  defp to_list(v) when is_list(v), do: v
+  defp to_list(_), do: []
+
+  defp interleave([], b), do: b
+  defp interleave(a, []), do: a
+  defp interleave([ha | ta], [hb | tb]), do: [ha, hb | interleave(ta, tb)]
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/remove_duplicates.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/remove_duplicates.ex
new file mode 100644
index 0000000..b2e7590
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/remove_duplicates.ex
@@ -0,0 +1,76 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.RemoveDuplicates do
+  @moduledoc """
+  Removes duplicate items based on a field value.
+
+  Keeps the first occurrence of each unique value.
+
+  ## Examples
+
+  Deduplicate coupled hotspots by entity:
+
+      parameters: %{"field" => "entity"}
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.remove_duplicates",
+      displayName: "Remove Duplicates",
+      group: "logic",
+      version: 1,
+      description: "Removes duplicate items based on a field value",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [%{name: "items", type: :any}],
+      parameters: [
+        %{
+          name: "field",
+          displayName: "Deduplicate By",
+          type: "string",
+          required: true,
+          description: "Field to check for duplicates"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    field = Map.get(parameters, "field", "")
+
+    if field == "" do
+      {:error, "field parameter is required"}
+    else
+      unique =
+        items
+        |> Enum.uniq_by(&get_field(&1, field))
+
+      Logger.info("Deduplicate by '#{field}': #{length(items)} → #{length(unique)}")
+      {:ok, %{items: unique}}
+    end
+  end
+
+  @impl true
+  def validate_parameters(params) do
+    if (Map.get(params, "field") || "") == "" do
+      {:error, [{:missing_required_parameter, "field"}]}
+    else
+      :ok
+    end
+  end
+
+  defp get_field(item, field) when is_map(item) do
+    Map.get(item, field) || Map.get(item, String.to_atom(field))
+  end
+
+  defp get_field(_, _), do: nil
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) -> list
+      _ -> input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/sort.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/sort.ex
new file mode 100644
index 0000000..098c694
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/sort.ex
@@ -0,0 +1,88 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.Sort do
+  @moduledoc """
+  Sorts items by a field value.
+
+  ## Examples
+
+  Sort hotspots by risk score descending (worst first):
+
+      parameters: %{"field" => "risk_score", "direction" => "desc"}
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.sort",
+      displayName: "Sort",
+      group: "logic",
+      version: 1,
+      description: "Sorts items by a field value",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [%{name: "items", type: :any}],
+      parameters: [
+        %{
+          name: "field",
+          displayName: "Sort By",
+          type: "string",
+          required: true,
+          description: "Field name to sort by"
+        },
+        %{
+          name: "direction",
+          displayName: "Direction",
+          type: "select",
+          required: false,
+          default: "asc",
+          options: [%{value: "asc", label: "Ascending"}, %{value: "desc", label: "Descending"}],
+          description: "Sort direction"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    field = Map.get(parameters, "field", "")
+    direction = Map.get(parameters, "direction", "asc")
+
+    if field == "" do
+      {:error, "field parameter is required"}
+    else
+      sorter = fn item -> get_field(item, field) end
+
+      sorted =
+        case direction do
+          "desc" -> Enum.sort_by(items, sorter, :desc)
+          _ -> Enum.sort_by(items, sorter, :asc)
+        end
+
+      Logger.info("Sorted #{length(sorted)} items by #{field} #{direction}")
+      {:ok, %{items: sorted}}
+    end
+  end
+
+  @impl true
+  def validate_parameters(params) do
+    if (Map.get(params, "field") || "") == "" do
+      {:error, [{:missing_required_parameter, "field"}]}
+    else
+      :ok
+    end
+  end
+
+  defp get_field(item, field) when is_map(item) do
+    Map.get(item, field) || Map.get(item, String.to_atom(field))
+  end
+
+  defp get_field(_, _), do: nil
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) -> list
+      _ -> input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/switch.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/switch.ex
new file mode 100644
index 0000000..9417885
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/logic/switch.ex
@@ -0,0 +1,116 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Logic.Switch do
+  @moduledoc """
+  Multi-way branch based on a field's value.
+
+  Like n8n's Switch node. Routes items to named output ports based on
+  which value a field holds. Items that don't match any case go to the
+  `default` output.
+
+  ## Examples
+
+  Route hotspots by risk level:
+
+      parameters: %{
+        "field" => "risk_factor",
+        "cases" => "high,medium,low"
+      }
+      # Outputs: high, medium, low, default
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.logic.switch",
+      displayName: "Switch",
+      group: "logic",
+      version: 1,
+      description: "Routes items to different outputs based on a field's value",
+      inputs: [%{name: "items", type: :any, required: true}],
+      outputs: [
+        %{name: "case_0", type: :any, description: "First case"},
+        %{name: "case_1", type: :any, description: "Second case"},
+        %{name: "case_2", type: :any, description: "Third case"},
+        %{name: "case_3", type: :any, description: "Fourth case"},
+        %{name: "default", type: :any, description: "Items not matching any case"}
+      ],
+      parameters: [
+        %{
+          name: "field",
+          displayName: "Field",
+          type: "string",
+          required: true,
+          description: "Field name to switch on"
+        },
+        %{
+          name: "cases",
+          displayName: "Cases",
+          type: "string",
+          required: true,
+          placeholder: "high,medium,low",
+          description: "Comma-separated values to match (maps to case_0, case_1, ...)"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    items = resolve_items(input_data)
+    field = Map.get(parameters, "field", "")
+    cases_str = Map.get(parameters, "cases", "")
+
+    if field == "" or cases_str == "" do
+      {:error, "field and cases parameters are required"}
+    else
+      case_values =
+        cases_str
+        |> String.split(",", trim: true)
+        |> Enum.map(&String.trim/1)
+
+      # Group items by which case they match
+      grouped =
+        Enum.group_by(items, fn item ->
+          item_val = get_field(item, field) |> to_string()
+          Enum.find_index(case_values, &(&1 == item_val))
+        end)
+
+      # Build output map with case_0, case_1, ... and default
+      output =
+        case_values
+        |> Enum.with_index()
+        |> Enum.reduce(%{}, fn {_val, idx}, acc ->
+          port = String.to_atom("case_#{idx}")
+          Map.put(acc, port, Map.get(grouped, idx, []))
+        end)
+        |> Map.put(:default, Map.get(grouped, nil, []))
+
+      counts = Enum.map(output, fn {k, v} -> "#{k}=#{length(v)}" end) |> Enum.join(", ")
+      Logger.info("Switch on '#{field}': #{counts}")
+      {:ok, output}
+    end
+  end
+
+  @impl true
+  def validate_parameters(params) do
+    cond do
+      (Map.get(params, "field") || "") == "" -> {:error, [{:missing_required_parameter, "field"}]}
+      (Map.get(params, "cases") || "") == "" -> {:error, [{:missing_required_parameter, "cases"}]}
+      true -> :ok
+    end
+  end
+
+  defp get_field(item, field) when is_map(item) do
+    Map.get(item, field) || Map.get(item, String.to_atom(field))
+  end
+
+  defp get_field(_, _), do: nil
+
+  defp resolve_items(input_data) do
+    case Map.get(input_data, :items) do
+      list when is_list(list) -> list
+      _ -> input_data |> Map.values() |> Enum.find([], &is_list/1)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/output/csv_export.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/output/csv_export.ex
new file mode 100644
index 0000000..6ca2e63
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/output/csv_export.ex
@@ -0,0 +1,241 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Output.CsvExport do
+  @moduledoc """
+  Flexible CSV export node that handles both direct data and nested data.
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.output.csv_export",
+      displayName: "CSV Export",
+      group: "output",
+      version: 1,
+      description: "Exports any list data to CSV format",
+      inputs: [
+        %{
+          name: "data",
+          type: :any,
+          required: true,
+          description: "Data to export (can be a list or a map containing a list)"
+        }
+      ],
+      outputs: [
+        %{
+          name: "file_path",
+          type: :string,
+          description: "Path to the exported CSV file"
+        },
+        %{
+          name: "records_exported",
+          type: :integer,
+          description: "Number of records exported"
+        }
+      ],
+      parameters: [
+        %{
+          name: "output_dir",
+          displayName: "Output Directory",
+          type: "string",
+          default: "/output",
+          required: true,
+          description: "Directory where the CSV file will be saved"
+        },
+        %{
+          name: "filename",
+          displayName: "Filename",
+          type: "string",
+          default: "export.csv",
+          required: false,
+          description: "Name of the CSV file"
+        },
+        %{
+          name: "columns",
+          displayName: "Columns",
+          type: "list",
+          default: nil,
+          required: false,
+          description: "Specific columns to export (nil exports all)"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    Logger.info("CSV Export started")
+    Logger.debug("Input data structure: #{inspect(Map.keys(input_data))}")
+
+    # The data comes directly on the :data port
+    raw_data = Map.get(input_data, :data)
+
+    Logger.debug(
+      "Raw data type: #{inspect(is_list(raw_data))}, first item: #{inspect(List.first(raw_data || []), limit: 3)}"
+    )
+
+    # Ensure we have a list to work with
+    data =
+      case raw_data do
+        nil ->
+          Logger.error("No data received on :data port")
+          nil
+
+        list when is_list(list) ->
+          Logger.info("Received list with #{length(list)} items")
+          list
+
+        other ->
+          Logger.error("Expected list but got: #{inspect(other)}")
+          nil
+      end
+
+    case data do
+      nil ->
+        {:error, "No data found to export"}
+
+      [] ->
+        {:error, "Data is empty"}
+
+      data_list ->
+        # Extract parameters
+        output_dir = Map.get(parameters, "output_dir", "/output")
+        filename = Map.get(parameters, "filename", "export.csv")
+        columns = Map.get(parameters, "columns")
+
+        # Ensure output directory exists
+        File.mkdir_p!(output_dir)
+
+        # Generate full file path
+        file_path = Path.join(output_dir, ensure_csv_extension(filename))
+
+        Logger.info("Exporting #{length(data_list)} records to #{file_path}")
+
+        # Export to CSV
+        case export_to_csv(data_list, file_path, columns) do
+          :ok ->
+            Logger.info("Successfully exported #{length(data_list)} records to #{file_path}")
+
+            {:ok,
+             %{
+               file_path: file_path,
+               records_exported: length(data_list)
+             }}
+
+          {:error, reason} ->
+            Logger.error("Failed to export CSV: #{inspect(reason)}")
+            {:error, "Failed to export CSV: #{inspect(reason)}"}
+        end
+    end
+  end
+
+  @impl true
+  def validate_parameters(parameters) do
+    output_dir = Map.get(parameters, "output_dir")
+
+    cond do
+      is_nil(output_dir) or output_dir == "" ->
+        {:error, [{:missing_required_parameter, "output_dir"}]}
+
+      true ->
+        :ok
+    end
+  end
+
+  # Private functions
+
+  defp ensure_csv_extension(filename) do
+    if String.ends_with?(filename, ".csv") do
+      filename
+    else
+      filename <> ".csv"
+    end
+  end
+
+  defp export_to_csv(data, file_path, specific_columns) do
+    try do
+      # Handle empty data
+      if Enum.empty?(data) do
+        File.write!(file_path, "")
+        :ok
+      end
+
+      # Get all unique keys from the data
+      all_keys =
+        data
+        |> Enum.flat_map(fn item ->
+          case item do
+            map when is_map(map) -> Map.keys(map)
+            _ -> []
+          end
+        end)
+        |> Enum.uniq()
+        |> Enum.map(&to_string/1)
+        |> Enum.sort()
+
+      # Use specific columns if provided, otherwise use all keys
+      columns = if specific_columns, do: specific_columns, else: all_keys
+
+      Logger.debug("Using columns: #{inspect(columns)}")
+
+      # Create CSV content
+      csv_content =
+        [
+          # Headers
+          Enum.join(columns, ","),
+          # Data rows
+          Enum.map(data, fn row ->
+            columns
+            |> Enum.map(fn col ->
+              value = get_value(row, col)
+              format_csv_value(value)
+            end)
+            |> Enum.join(",")
+          end)
+        ]
+        |> List.flatten()
+        |> Enum.join("\n")
+
+      # Write to file
+      File.write!(file_path, csv_content)
+
+      Logger.info("CSV file written successfully")
+      :ok
+    rescue
+      e ->
+        Logger.error("Exception during CSV export: #{inspect(e)}")
+        {:error, Exception.message(e)}
+    end
+  end
+
+  defp get_value(row, column) when is_map(row) do
+    # Try string key first, then atom key
+    Map.get(row, column) || Map.get(row, String.to_atom(column)) || ""
+  end
+
+  defp get_value(_, _), do: ""
+
+  defp format_csv_value(value) when is_binary(value) do
+    # Escape quotes and wrap in quotes if contains comma, quote, or newline
+    if String.contains?(value, [",", "\"", "\n", "\r"]) do
+      "\"" <> String.replace(value, "\"", "\"\"") <> "\""
+    else
+      value
+    end
+  end
+
+  defp format_csv_value(value) when is_float(value),
+    do: :erlang.float_to_binary(value, decimals: 2)
+
+  defp format_csv_value(value) when is_integer(value), do: Integer.to_string(value)
+  defp format_csv_value(true), do: "true"
+  defp format_csv_value(false), do: "false"
+  defp format_csv_value(:high), do: "high"
+  defp format_csv_value(:medium), do: "medium"
+  defp format_csv_value(:low), do: "low"
+  defp format_csv_value(value) when is_atom(value), do: Atom.to_string(value)
+  defp format_csv_value(%DateTime{} = dt), do: DateTime.to_iso8601(dt)
+  defp format_csv_value(%Date{} = d), do: Date.to_iso8601(d)
+  defp format_csv_value(nil), do: ""
+  defp format_csv_value(value), do: inspect(value)
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/transform/extract_field.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/transform/extract_field.ex
new file mode 100644
index 0000000..07cd301
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/transform/extract_field.ex
@@ -0,0 +1,92 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Transform.ExtractField do
+  @moduledoc """
+  Transform node that extracts a specific field from input data.
+
+  Useful for reshaping data between nodes when output/input ports don't match.
+  For example, extracting the 'hotspots' field to pass just the list to another node.
+  """
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.transform.extract_field",
+      displayName: "Extract Field",
+      group: "transform",
+      version: 1,
+      description: "Extracts a specific field from the input data",
+      inputs: [
+        %{
+          name: "input",
+          type: :any,
+          required: true,
+          description: "Input data containing the field to extract"
+        }
+      ],
+      outputs: [
+        %{
+          name: "output",
+          type: :any,
+          description: "The extracted field value"
+        }
+      ],
+      parameters: [
+        %{
+          name: "field_name",
+          displayName: "Field Name",
+          type: "string",
+          required: true,
+          description: "Name of the field to extract (e.g., 'hotspots', 'results')"
+        },
+        %{
+          name: "default_value",
+          displayName: "Default Value",
+          type: "any",
+          default: nil,
+          required: false,
+          description: "Value to use if field doesn't exist"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(input_data, parameters, _context) do
+    field_name = Map.get(parameters, "field_name") || Map.get(parameters, :field_name)
+    default_value = Map.get(parameters, "default_value", nil)
+
+    if is_nil(field_name) or field_name == "" do
+      {:error, "field_name parameter is required"}
+    else
+      # Extract the field value
+      value = extract_field_value(input_data, field_name, default_value)
+
+      Logger.info("Extracted field '#{field_name}': #{inspect(value, limit: 5)}")
+
+      {:ok, %{output: value}}
+    end
+  end
+
+  @impl true
+  def validate_parameters(parameters) do
+    field_name = Map.get(parameters, "field_name") || Map.get(parameters, :field_name)
+
+    if is_nil(field_name) or field_name == "" do
+      {:error, [{:missing_required_parameter, "field_name"}]}
+    else
+      :ok
+    end
+  end
+
+  defp extract_field_value(data, field_name, default) when is_map(data) do
+    # Try both string and atom keys
+    # Check the 'input' port
+    Map.get(data, field_name) ||
+      Map.get(data, String.to_atom(field_name)) ||
+      Map.get(data, :input) ||
+      default
+  end
+
+  defp extract_field_value(_data, _field_name, default), do: default
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/triggers/git_commits.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/triggers/git_commits.ex
new file mode 100644
index 0000000..2260e4d
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/nodes/triggers/git_commits.ex
@@ -0,0 +1,170 @@
+defmodule GitlockWorkflows.Runtime.Nodes.Triggers.GitCommits do
+  use GitlockWorkflows.Runtime.Node
+  require Logger
+
+  alias GitlockWorkflows.Executor
+
+  @impl true
+  def metadata do
+    %{
+      id: "gitlock.trigger.git_commits",
+      displayName: "Git Commits Trigger",
+      group: "trigger",
+      version: 1,
+      description: "Triggers workflow execution when analyzing git commit history",
+      inputs: [],
+      outputs: [
+        %{
+          name: "commits",
+          type: {:list, :map},
+          required: true,
+          description: "Raw commits data"
+        },
+        %{
+          name: "repo_path",
+          type: :string,
+          required: true,
+          description: "Resolved local path to the git repository (for downstream nodes)"
+        }
+      ],
+      parameters: [
+        %{
+          name: "repo_path",
+          displayName: "Repository Path",
+          type: "string",
+          default: "",
+          required: true,
+          description: "Path to the git repository to analyze"
+        }
+      ]
+    }
+  end
+
+  @impl true
+  def execute(_input_data, parameters, context) do
+    Logger.info("Git commits trigger started")
+
+    repo_path = Map.get(parameters, "repo_path") || Map.get(parameters, :repo_path) || ""
+
+    if repo_path == "" or is_nil(repo_path) do
+      Logger.error("Repository path is empty or nil. Parameters: #{inspect(parameters)}")
+      {:error, "Repository path is required"}
+    else
+      Logger.info("Fetching commits for repo: #{repo_path}")
+
+      progress_fn = fn message ->
+        Executor.report_status(context, message)
+      end
+
+      user_git_options = Map.get(parameters, "git_options", %{})
+
+      git_options =
+        user_git_options
+        |> atomize_keys()
+        |> Map.put(:progress_fn, progress_fn)
+
+      filters = describe_filters(git_options)
+      if filters != "", do: Executor.report_status(context, "Filters: #{filters}")
+
+      case GitlockCore.Adapters.VCS.Git.get_commit_history(repo_path, git_options) do
+        {:ok, commits} ->
+          # Resolve the local path where git commands can run
+          # (for remote URLs this is the clone directory)
+          resolved_path = resolve_local_path(repo_path)
+
+          Executor.report_status(context, "Parsed #{length(commits)} commits")
+          Logger.info("Successfully fetched #{length(commits)} commits")
+          {:ok, %{commits: commits, repo_path: resolved_path}}
+
+        {:error, reason} ->
+          Logger.error("Failed to fetch commits: #{inspect(reason)}")
+          {:error, format_error(reason)}
+      end
+    end
+  end
+
+  # Resolve a repo source to a local path where git commands can be executed.
+  # For remote URLs, this is the cached clone directory.
+  # For local paths, it's the path itself.
+  defp resolve_local_path(source) do
+    if remote_url?(source) do
+      hash =
+        :crypto.hash(:sha256, source)
+        |> Base.url_encode64(padding: false)
+        |> String.slice(0..11)
+
+      repo_name =
+        source
+        |> String.split("/")
+        |> List.last()
+        |> String.replace(~r/\.git$/, "")
+
+      Path.join([System.tmp_dir!(), "gitlock", "clones", "#{repo_name}_#{hash}"])
+    else
+      source
+    end
+  end
+
+  defp remote_url?(path) do
+    String.starts_with?(path, "https://") or
+      String.starts_with?(path, "http://") or
+      String.starts_with?(path, "git@") or
+      String.starts_with?(path, "ssh://")
+  end
+
+  defp atomize_keys(map) when is_map(map) do
+    Map.new(map, fn
+      {k, v} when is_binary(k) ->
+        try do
+          {String.to_existing_atom(k), v}
+        rescue
+          _ -> {String.to_atom(k), v}
+        end
+
+      {k, v} ->
+        {k, v}
+    end)
+  end
+
+  defp describe_filters(opts) do
+    parts =
+      []
+      |> then(fn acc -> if opts[:since], do: ["since #{opts[:since]}" | acc], else: acc end)
+      |> then(fn acc -> if opts[:until], do: ["until #{opts[:until]}" | acc], else: acc end)
+      |> then(fn acc ->
+        if opts[:max_count], do: ["last #{opts[:max_count]} commits" | acc], else: acc
+      end)
+      |> then(fn acc -> if opts[:path], do: ["path: #{opts[:path]}" | acc], else: acc end)
+      |> Enum.reverse()
+
+    Enum.join(parts, ", ")
+  end
+
+  defp format_error(reason) when is_binary(reason) do
+    cond do
+      String.contains?(reason, "clone failed") ->
+        "Failed to clone repository. Check that the URL is correct and the repo is public."
+
+      String.contains?(reason, "not a git repository") ->
+        "The specified path is not a git repository."
+
+      String.contains?(reason, "Could not resolve host") ->
+        "Could not reach the repository host. Check your network connection."
+
+      true ->
+        reason
+    end
+  end
+
+  defp format_error(reason), do: inspect(reason)
+
+  @impl true
+  def validate_parameters(parameters) do
+    repo_path = Map.get(parameters, "repo_path") || Map.get(parameters, :repo_path) || ""
+
+    case repo_path do
+      "" -> {:error, "repo_path is required"}
+      _ -> :ok
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/registry.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/registry.ex
new file mode 100644
index 0000000..284c142
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/registry.ex
@@ -0,0 +1,825 @@
+defmodule GitlockWorkflows.Runtime.Registry do
+  @moduledoc """
+  Central registry for available nodes and their metadata.
+
+  The Registry provides:
+  - Node discovery and registration
+  - Metadata caching and retrieval
+  - Node validation
+  - Category-based organization
+  - Search functionality
+  - Plugin support
+
+  ## Node Registration
+
+  Nodes are automatically registered at application startup:
+
+      # In your application.ex
+      def start(_type, _args) do
+        # Register all built-in nodes
+        GitlockWorkflows.Runtime.Registry.register_builtin_nodes()
+        
+        # Register plugin nodes
+        GitlockWorkflows.Runtime.Registry.register_plugin_nodes()
+        
+        # ... rest of supervision tree
+      end
+
+  ## Custom Node Registration
+
+      defmodule MyCustomNode do
+        use GitlockWorkflows.Runtime.Node
+        
+        def metadata do
+          %{
+            id: "my_company.analysis.custom",
+            displayName: "Custom Analysis",
+            group: "analysis",
+            version: 1,
+            description: "My custom analysis node",
+            inputs: [
+              %{name: "data", type: :list, required: true}
+            ],
+            outputs: [
+              %{name: "result", type: :map}
+            ],
+            parameters: [
+              %{name: "threshold", type: "number", default: 10}
+            ]
+          }
+        end
+        
+        def execute(input, params, context) do
+          # Your implementation
+          {:ok, %{result: "processed"}}
+        end
+      end
+      
+      # Register it
+      GitlockWorkflows.Runtime.Registry.register_node(MyCustomNode)
+
+  ## Node Discovery
+
+      # List all nodes
+      nodes = GitlockWorkflows.Runtime.Registry.list_nodes()
+      
+      # Get specific node
+      {:ok, module} = GitlockWorkflows.Runtime.Registry.get_node("gitlock.analysis.hotspot")
+      
+      # Search nodes
+      analysis_nodes = GitlockWorkflows.Runtime.Registry.search_nodes("analysis")
+      
+      # List by category
+      triggers = GitlockWorkflows.Runtime.Registry.list_nodes_by_category("trigger")
+  """
+  use GenServer
+  require Logger
+
+  @typedoc "Node metadata structure"
+  @type node_metadata :: %{
+          id: String.t(),
+          displayName: String.t(),
+          group: String.t(),
+          version: integer(),
+          description: String.t(),
+          inputs: [port_definition()],
+          outputs: [port_definition()],
+          parameters: [parameter_definition()],
+          tags: [String.t()],
+          deprecated: boolean(),
+          experimental: boolean()
+        }
+
+  @typedoc "Port definition"
+  @type port_definition :: %{
+          name: String.t(),
+          type: atom(),
+          required: boolean(),
+          description: String.t()
+        }
+
+  @typedoc "Parameter definition"
+  @type parameter_definition :: %{
+          name: String.t(),
+          type: String.t(),
+          default: any(),
+          required: boolean(),
+          description: String.t(),
+          options: [any()] | nil
+        }
+
+  @typedoc "Registry state"
+  @type state :: %{
+          nodes: %{String.t() => {module(), node_metadata()}},
+          by_category: %{String.t() => [String.t()]},
+          search_index: %{String.t() => [String.t()]},
+          stats: %{
+            total_nodes: non_neg_integer(),
+            nodes_by_group: %{String.t() => non_neg_integer()},
+            last_updated: DateTime.t()
+          }
+        }
+
+  # Client API
+
+  @doc """
+  Starts the node registry.
+
+  Usually called by the supervisor.
+  """
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+  end
+
+  @doc """
+  Registers a node in the registry.
+
+  ## Parameters
+    * `module` - The node module implementing the Node behaviour
+
+  ## Returns
+    * `:ok` - Node registered successfully
+    * `{:error, reason}` - Registration failed
+
+  ## Examples
+
+      defmodule MyNode do
+        use GitlockWorkflows.Runtime.Node
+        # ... implementation
+      end
+      
+      :ok = Registry.register_node(MyNode)
+  """
+  @spec register_node(module()) :: :ok | {:error, term()}
+  def register_node(module) when is_atom(module) do
+    GenServer.call(__MODULE__, {:register_node, module})
+  end
+
+  @doc """
+  Registers multiple nodes at once.
+
+  ## Parameters
+    * `modules` - List of node modules
+
+  ## Returns
+    * `:ok` - All nodes registered successfully
+    * `{:error, failures}` - Some nodes failed to register
+
+  ## Examples
+
+      modules = [NodeA, NodeB, NodeC]
+      :ok = Registry.register_nodes(modules)
+  """
+  @spec register_nodes([module()]) :: :ok | {:error, map()}
+  def register_nodes(modules) when is_list(modules) do
+    GenServer.call(__MODULE__, {:register_nodes, modules})
+  end
+
+  @doc """
+  Gets a node module by its ID.
+
+  ## Parameters
+    * `node_id` - The node identifier
+
+  ## Returns
+    * `{:ok, module}` - Node found
+    * `{:error, :not_found}` - Node not found
+
+  ## Examples
+
+      case Registry.get_node("gitlock.analysis.hotspot") do
+        {:ok, module} -> 
+          # Use the module
+          metadata = module.metadata()
+          
+        {:error, :not_found} ->
+          IO.puts("Node not found")
+      end
+  """
+  @spec get_node(String.t()) :: {:ok, module()} | {:error, :not_found}
+  def get_node(node_id) when is_binary(node_id) do
+    GenServer.call(__MODULE__, {:get_node, node_id})
+  end
+
+  @doc ~S"""
+  Gets node metadata by ID.
+
+  ## Parameters
+    * `node_id` - The node identifier
+
+  ## Returns
+    * `{:ok, metadata}` - Metadata found
+    * `{:error, :not_found}` - Node not found
+
+  ## Examples
+
+      {:ok, metadata} = Registry.get_metadata("gitlock.analysis.hotspot")
+      IO.puts("Node: #{metadata.displayName}")
+      IO.puts("Description: #{metadata.description}")
+  """
+  @spec get_metadata(String.t()) :: {:ok, node_metadata()} | {:error, :not_found}
+  def get_metadata(node_id) when is_binary(node_id) do
+    GenServer.call(__MODULE__, {:get_metadata, node_id})
+  end
+
+  @doc ~S"""
+  Lists all registered nodes.
+
+  ## Returns
+    List of node metadata
+
+  ## Examples
+
+      nodes = Registry.list_nodes()
+      
+      Enum.each(nodes, fn metadata ->
+        IO.puts("#{metadata.id}: #{metadata.displayName}")
+      end)
+  """
+  @spec list_nodes() :: [node_metadata()]
+  def list_nodes do
+    GenServer.call(__MODULE__, :list_nodes)
+  end
+
+  @doc """
+  Lists nodes by category/group.
+
+  ## Parameters
+    * `category` - The category to filter by
+
+  ## Returns
+    List of node metadata in the specified category
+
+  ## Examples
+
+      # Get all analysis nodes
+      analysis_nodes = Registry.list_nodes_by_category("analysis")
+      
+      # Get all triggers
+      triggers = Registry.list_nodes_by_category("trigger")
+  """
+  @spec list_nodes_by_category(String.t()) :: [node_metadata()]
+  def list_nodes_by_category(category) when is_binary(category) do
+    GenServer.call(__MODULE__, {:list_nodes_by_category, category})
+  end
+
+  @doc """
+  Lists all available categories.
+
+  ## Returns
+    List of category names
+
+  ## Examples
+
+      categories = Registry.list_categories()
+      # Returns: ["trigger", "analysis", "transform", "output"]
+  """
+  @spec list_categories() :: [String.t()]
+  def list_categories do
+    GenServer.call(__MODULE__, :list_categories)
+  end
+
+  @doc """
+  Searches for nodes by query.
+
+  Searches in node ID, display name, description, and tags.
+
+  ## Parameters
+    * `query` - The search query
+
+  ## Returns
+    List of matching node metadata
+
+  ## Examples
+
+      # Search for hotspot-related nodes
+      hotspot_nodes = Registry.search_nodes("hotspot")
+      
+      # Search for Git-related nodes
+      git_nodes = Registry.search_nodes("git")
+      
+      # Search for analysis nodes
+      analysis_nodes = Registry.search_nodes("analysis")
+  """
+  @spec search_nodes(String.t()) :: [node_metadata()]
+  def search_nodes(query) when is_binary(query) do
+    GenServer.call(__MODULE__, {:search_nodes, query})
+  end
+
+  @doc ~S"""
+  Validates that a node is properly implemented.
+
+  ## Parameters
+    * `module` - The node module to validate
+
+  ## Returns
+    * `:ok` - Node is valid
+    * `{:error, reasons}` - Node is invalid
+
+  ## Examples
+
+      case Registry.validate_node(MyNode) do
+        :ok -> IO.puts("Node is valid")
+        {:error, reasons} -> IO.puts("Validation errors: #{inspect(reasons)}")
+      end
+  """
+  @spec validate_node(module()) :: :ok | {:error, [term()]}
+  def validate_node(module) when is_atom(module) do
+    GenServer.call(__MODULE__, {:validate_node, module})
+  end
+
+  @doc ~S"""
+  Gets registry statistics.
+
+  ## Returns
+    Map containing registry statistics
+
+  ## Examples
+
+      stats = Registry.get_stats()
+      IO.puts("Total nodes: #{stats.total_nodes}")
+      IO.puts("Analysis nodes: #{stats.nodes_by_group["analysis"]}")
+  """
+  @spec get_stats() :: map()
+  def get_stats do
+    GenServer.call(__MODULE__, :get_stats)
+  end
+
+  @doc """
+  Registers all built-in nodes.
+
+  This is called automatically at application startup.
+
+  ## Returns
+    * `:ok` - All nodes registered successfully
+    * `{:error, failures}` - Some nodes failed to register
+  """
+  @spec register_builtin_nodes() :: :ok | {:error, map()}
+  def register_builtin_nodes do
+    # Derive builtin nodes from the NodeCatalog (single source of truth)
+    catalog_modules = GitlockWorkflows.NodeCatalog.runtime_modules()
+
+    # Also include runtime-only nodes not in the visual catalog
+    # (transform nodes, output nodes used only in the runtime)
+    extra_modules = [
+      GitlockWorkflows.Runtime.Nodes.Analysis.Complexity,
+      GitlockWorkflows.Runtime.Nodes.Transform.ExtractField,
+      GitlockWorkflows.Runtime.Nodes.Output.CsvExport
+    ]
+
+    all_modules = Enum.uniq(catalog_modules ++ extra_modules)
+    available = Enum.filter(all_modules, &Code.ensure_loaded?/1)
+    register_nodes(available)
+  end
+
+  @doc """
+  Registers plugin nodes from configured applications.
+
+  This scans configured applications for node modules and registers them.
+
+  ## Returns
+    * `:ok` - All plugin nodes registered successfully
+    * `{:error, failures}` - Some nodes failed to register
+  """
+  @spec register_plugin_nodes() :: :ok | {:error, map()}
+  def register_plugin_nodes do
+    plugin_apps = Application.get_env(:gitlock_core, :plugin_apps, [])
+
+    plugin_nodes =
+      plugin_apps
+      |> Enum.flat_map(&discover_nodes_in_app/1)
+
+    case plugin_nodes do
+      [] -> :ok
+      nodes -> register_nodes(nodes)
+    end
+  end
+
+  @doc """
+  Unregisters a node from the registry.
+
+  ## Parameters
+    * `node_id` - The node identifier
+
+  ## Returns
+    * `:ok` - Node unregistered successfully
+    * `{:error, :not_found}` - Node not found
+
+  ## Examples
+
+      :ok = Registry.unregister_node("my_custom_node")
+  """
+  @spec unregister_node(String.t()) :: :ok | {:error, :not_found}
+  def unregister_node(node_id) when is_binary(node_id) do
+    GenServer.call(__MODULE__, {:unregister_node, node_id})
+  end
+
+  # Server Implementation
+
+  @impl GenServer
+  def init(_opts) do
+    Logger.info("Starting Runtime.Registry")
+
+    state = %{
+      nodes: %{},
+      by_category: %{},
+      search_index: %{},
+      stats: %{
+        total_nodes: 0,
+        nodes_by_group: %{},
+        last_updated: DateTime.utc_now()
+      }
+    }
+
+    {:ok, state}
+  end
+
+  @impl GenServer
+  def handle_call({:register_node, module}, _from, state) do
+    case do_register_node(module, state) do
+      {:ok, new_state} ->
+        {:reply, :ok, new_state}
+
+      {:error, reason} ->
+        {:reply, {:error, reason}, state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call({:register_nodes, modules}, _from, state) do
+    {failures, final_state} =
+      Enum.reduce(modules, {%{}, state}, fn module, {failures, acc_state} ->
+        case do_register_node(module, acc_state) do
+          {:ok, new_state} ->
+            {failures, new_state}
+
+          {:error, reason} ->
+            {Map.put(failures, module, reason), acc_state}
+        end
+      end)
+
+    if map_size(failures) == 0 do
+      {:reply, :ok, final_state}
+    else
+      {:reply, {:error, failures}, final_state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call({:get_node, node_id}, _from, state) do
+    case Map.get(state.nodes, node_id) do
+      {module, _metadata} -> {:reply, {:ok, module}, state}
+      nil -> {:reply, {:error, :not_found}, state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call({:get_metadata, node_id}, _from, state) do
+    case Map.get(state.nodes, node_id) do
+      {_module, metadata} -> {:reply, {:ok, metadata}, state}
+      nil -> {:reply, {:error, :not_found}, state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call(:list_nodes, _from, state) do
+    nodes =
+      state.nodes
+      |> Map.values()
+      |> Enum.map(fn {_module, metadata} -> metadata end)
+      |> Enum.sort_by(& &1.displayName)
+
+    {:reply, nodes, state}
+  end
+
+  @impl GenServer
+  def handle_call({:list_nodes_by_category, category}, _from, state) do
+    node_ids = Map.get(state.by_category, category, [])
+
+    nodes =
+      node_ids
+      |> Enum.map(&Map.get(state.nodes, &1))
+      |> Enum.reject(&is_nil/1)
+      |> Enum.map(fn {_module, metadata} -> metadata end)
+      |> Enum.sort_by(& &1.displayName)
+
+    {:reply, nodes, state}
+  end
+
+  @impl GenServer
+  def handle_call(:list_categories, _from, state) do
+    categories =
+      state.by_category
+      |> Map.keys()
+      |> Enum.sort()
+
+    {:reply, categories, state}
+  end
+
+  @impl GenServer
+  def handle_call({:search_nodes, query}, _from, state) do
+    query_lower = String.downcase(query)
+
+    matching_nodes =
+      state.nodes
+      |> Map.values()
+      |> Enum.filter(fn {_module, metadata} ->
+        search_matches?(metadata, query_lower)
+      end)
+      |> Enum.map(fn {_module, metadata} -> metadata end)
+      |> Enum.sort_by(& &1.displayName)
+
+    {:reply, matching_nodes, state}
+  end
+
+  @impl GenServer
+  def handle_call({:validate_node, module}, _from, state) do
+    case do_validate_node(module) do
+      :ok -> {:reply, :ok, state}
+      {:error, reasons} -> {:reply, {:error, reasons}, state}
+    end
+  end
+
+  @impl GenServer
+  def handle_call(:get_stats, _from, state) do
+    {:reply, state.stats, state}
+  end
+
+  @impl GenServer
+  def handle_call({:unregister_node, node_id}, _from, state) do
+    case Map.get(state.nodes, node_id) do
+      nil ->
+        {:reply, {:error, :not_found}, state}
+
+      {_module, metadata} ->
+        new_state = remove_node_from_state(node_id, metadata, state)
+        {:reply, :ok, new_state}
+    end
+  end
+
+  # Private Functions
+
+  defp do_register_node(module, state) do
+    with :ok <- do_validate_node(module),
+         {:ok, metadata} <- get_module_metadata(module) do
+      Logger.info("Registering node: #{metadata.id} (#{metadata.displayName})")
+
+      new_state = add_node_to_state(module, metadata, state)
+      {:ok, new_state}
+    else
+      error -> error
+    end
+  end
+
+  defp do_validate_node(module) do
+    errors = []
+
+    # Check if module exists
+    errors =
+      if Code.ensure_loaded?(module) do
+        errors
+      else
+        [{:module_not_loaded, module} | errors]
+      end
+
+    # Check if module implements required functions
+    required_functions = [:metadata, :execute]
+
+    errors =
+      Enum.reduce(required_functions, errors, fn function, acc ->
+        if function_exported?(module, function, 0) or function_exported?(module, function, 3) do
+          acc
+        else
+          [{:missing_function, function} | acc]
+        end
+      end)
+
+    # Check metadata structure
+    errors =
+      case get_module_metadata(module) do
+        {:ok, metadata} -> validate_metadata(metadata, errors)
+        {:error, reason} -> [{:invalid_metadata, reason} | errors]
+      end
+
+    if Enum.empty?(errors) do
+      :ok
+    else
+      {:error, Enum.reverse(errors)}
+    end
+  end
+
+  defp get_module_metadata(module) do
+    try do
+      metadata = module.metadata()
+      {:ok, normalize_metadata(metadata)}
+    rescue
+      error -> {:error, error}
+    end
+  end
+
+  defp normalize_metadata(metadata) do
+    %{
+      id: Map.get(metadata, :id),
+      displayName: Map.get(metadata, :displayName) || Map.get(metadata, :id),
+      group: Map.get(metadata, :group, "other"),
+      version: Map.get(metadata, :version, 1),
+      description: Map.get(metadata, :description, ""),
+      inputs: Map.get(metadata, :inputs, []),
+      outputs: Map.get(metadata, :outputs, []),
+      parameters: Map.get(metadata, :parameters, []),
+      tags: Map.get(metadata, :tags, []),
+      deprecated: Map.get(metadata, :deprecated, false),
+      experimental: Map.get(metadata, :experimental, false)
+    }
+  end
+
+  defp validate_metadata(metadata, errors) do
+    errors =
+      if is_binary(Map.get(metadata, :id)) and String.length(Map.get(metadata, :id)) > 0 do
+        errors
+      else
+        [{:invalid_id, Map.get(metadata, :id)} | errors]
+      end
+
+    errors =
+      if is_binary(Map.get(metadata, :displayName)) and
+           String.length(Map.get(metadata, :displayName)) > 0 do
+        errors
+      else
+        [{:invalid_display_name, Map.get(metadata, :displayName)} | errors]
+      end
+
+    errors =
+      if is_list(Map.get(metadata, :inputs)) do
+        errors
+      else
+        [{:invalid_inputs, Map.get(metadata, :inputs)} | errors]
+      end
+
+    errors =
+      if is_list(Map.get(metadata, :outputs)) do
+        errors
+      else
+        [{:invalid_outputs, Map.get(metadata, :outputs)} | errors]
+      end
+
+    errors
+  end
+
+  defp add_node_to_state(module, metadata, state) do
+    # Add to main nodes map
+    nodes = Map.put(state.nodes, metadata.id, {module, metadata})
+
+    # Add to category index
+    category_nodes = Map.get(state.by_category, metadata.group, [])
+    by_category = Map.put(state.by_category, metadata.group, [metadata.id | category_nodes])
+
+    # Update search index
+    search_index = add_to_search_index(metadata, state.search_index)
+
+    # Update stats
+    stats = update_stats_for_addition(metadata, state.stats)
+
+    %{
+      state
+      | nodes: nodes,
+        by_category: by_category,
+        search_index: search_index,
+        stats: stats
+    }
+  end
+
+  defp remove_node_from_state(node_id, metadata, state) do
+    # Remove from main nodes map
+    nodes = Map.delete(state.nodes, node_id)
+
+    # Remove from category index
+    category_nodes = Map.get(state.by_category, metadata.group, [])
+    updated_category_nodes = List.delete(category_nodes, node_id)
+
+    by_category =
+      if Enum.empty?(updated_category_nodes) do
+        Map.delete(state.by_category, metadata.group)
+      else
+        Map.put(state.by_category, metadata.group, updated_category_nodes)
+      end
+
+    # Update search index
+    search_index = remove_from_search_index(metadata, state.search_index)
+
+    # Update stats
+    stats = update_stats_for_removal(metadata, state.stats)
+
+    %{
+      state
+      | nodes: nodes,
+        by_category: by_category,
+        search_index: search_index,
+        stats: stats
+    }
+  end
+
+  defp add_to_search_index(metadata, search_index) do
+    search_terms = extract_search_terms(metadata)
+
+    Enum.reduce(search_terms, search_index, fn term, acc ->
+      existing = Map.get(acc, term, [])
+      Map.put(acc, term, [metadata.id | existing])
+    end)
+  end
+
+  defp remove_from_search_index(metadata, search_index) do
+    search_terms = extract_search_terms(metadata)
+
+    Enum.reduce(search_terms, search_index, fn term, acc ->
+      case Map.get(acc, term) do
+        nil -> acc
+        # Remove term if this was the only node
+        [_] -> Map.delete(acc, term)
+        list -> Map.put(acc, term, List.delete(list, metadata.id))
+      end
+    end)
+  end
+
+  defp extract_search_terms(metadata) do
+    [
+      metadata.id,
+      metadata.displayName,
+      metadata.group,
+      metadata.description
+    ]
+    |> Enum.concat(metadata.tags)
+    |> Enum.flat_map(fn term ->
+      term
+      |> String.downcase()
+      |> String.split([" ", ".", "_", "-"], trim: true)
+    end)
+    |> Enum.uniq()
+  end
+
+  defp search_matches?(metadata, query) do
+    search_text =
+      [
+        metadata.id,
+        metadata.displayName,
+        metadata.group,
+        metadata.description
+      ]
+      |> Enum.concat(metadata.tags)
+      |> Enum.join(" ")
+      |> String.downcase()
+
+    String.contains?(search_text, query)
+  end
+
+  defp update_stats_for_addition(metadata, stats) do
+    group_count = Map.get(stats.nodes_by_group, metadata.group, 0)
+
+    %{
+      stats
+      | total_nodes: stats.total_nodes + 1,
+        nodes_by_group: Map.put(stats.nodes_by_group, metadata.group, group_count + 1),
+        last_updated: DateTime.utc_now()
+    }
+  end
+
+  defp update_stats_for_removal(metadata, stats) do
+    group_count = Map.get(stats.nodes_by_group, metadata.group, 1)
+
+    nodes_by_group =
+      if group_count <= 1 do
+        Map.delete(stats.nodes_by_group, metadata.group)
+      else
+        Map.put(stats.nodes_by_group, metadata.group, group_count - 1)
+      end
+
+    %{
+      stats
+      | total_nodes: stats.total_nodes - 1,
+        nodes_by_group: nodes_by_group,
+        last_updated: DateTime.utc_now()
+    }
+  end
+
+  defp discover_nodes_in_app(app_name) do
+    case Application.spec(app_name, :modules) do
+      nil ->
+        []
+
+      modules ->
+        modules
+        |> Enum.filter(&implements_node_behaviour?/1)
+    end
+  end
+
+  defp implements_node_behaviour?(module) do
+    try do
+      Code.ensure_loaded?(module) and
+        function_exported?(module, :metadata, 0) and
+        function_exported?(module, :execute, 3)
+    rescue
+      _ -> false
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/validator.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/validator.ex
new file mode 100644
index 0000000..3b4c3b7
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/validator.ex
@@ -0,0 +1,878 @@
+defmodule GitlockWorkflows.Runtime.Validator do
+  @moduledoc """
+  Validates workflow structure, node connections, and execution readiness.
+
+  This module provides comprehensive validation for workflows including:
+  - Structural validation (nodes, connections, parameters)
+  - Port type compatibility checking
+  - Circular dependency detection
+  - Node parameter validation
+  - Workflow execution readiness checks
+
+  ## Examples
+
+      iex> workflow = %Workflow{nodes: [...], connections: [...]}
+      iex> Validator.validate_workflow(workflow)
+      {:ok, workflow}
+
+      iex> Validator.validate_workflow(invalid_workflow)
+      {:error, [
+        {:missing_required_parameter, "node_1", "threshold"},
+        {:cycle_detected, ["node_1", "node_2", "node_3", "node_1"]}
+      ]}
+  """
+
+  alias GitlockWorkflows.Runtime.{Workflow, Registry}
+  require Logger
+
+  @typedoc "Validation error types"
+  @type validation_error ::
+          {:unknown_node_type, node_id :: String.t(), type :: String.t()}
+          | {:missing_required_parameter, node_id :: String.t(), param_name :: String.t()}
+          | {:invalid_parameter_type, node_id :: String.t(), param_name :: String.t(),
+             expected :: String.t(), actual :: any()}
+          | {:invalid_parameter_value, node_id :: String.t(), param_name :: String.t(),
+             reason :: String.t()}
+          | {:connection_missing_from_node, node_id :: String.t()}
+          | {:connection_missing_to_node, node_id :: String.t()}
+          | {:unknown_output_port, node_id :: String.t(), port :: String.t()}
+          | {:unknown_input_port, node_id :: String.t(), port :: String.t()}
+          | {:incompatible_port_types, from :: String.t(), to :: String.t(), reason :: String.t()}
+          | {:cycle_detected, path :: [String.t()]}
+          | {:orphan_node, node_id :: String.t()}
+          | {:duplicate_node_id, node_id :: String.t()}
+          | {:duplicate_connection, from :: String.t(), to :: String.t()}
+          | {:empty_workflow}
+          | {:no_trigger_nodes}
+          | {:multiple_inputs_to_port, node_id :: String.t(), port :: String.t()}
+          | {:required_input_not_connected, node_id :: String.t(), port :: String.t()}
+          | {:disabled_node_in_critical_path, node_id :: String.t()}
+
+  @typedoc "Port compatibility result"
+  @type compatibility_result :: :compatible | {:incompatible, reason :: String.t()}
+
+  @doc """
+  Performs comprehensive validation of a workflow.
+
+  Validates:
+  - Workflow structure
+  - Node definitions and parameters
+  - Connection validity and port compatibility
+  - Circular dependencies
+  - Execution readiness
+
+  ## Examples
+
+      iex> Validator.validate_workflow(workflow)
+      {:ok, workflow}
+
+      iex> Validator.validate_workflow(invalid_workflow)
+      {:error, [{:unknown_node_type, "node_1", "invalid.type"}]}
+  """
+  @spec validate_workflow(Workflow.t()) :: {:ok, Workflow.t()} | {:error, [validation_error()]}
+  def validate_workflow(%Workflow{} = workflow) do
+    Logger.debug("Validating workflow: #{workflow.id}")
+
+    # Collect ALL errors from all validation steps
+    all_errors = []
+
+    # Structure validation
+    all_errors =
+      case validate_structure(workflow) do
+        {:ok, _} -> all_errors
+        {:error, errors} -> all_errors ++ errors
+      end
+
+    # Node validation
+    all_errors =
+      case validate_nodes(workflow) do
+        {:ok, _} -> all_errors
+        {:error, errors} -> all_errors ++ errors
+      end
+
+    # Connection validation
+    all_errors =
+      case validate_connections(workflow) do
+        {:ok, _} -> all_errors
+        {:error, errors} -> all_errors ++ errors
+      end
+
+    # Topology validation
+    all_errors =
+      case validate_topology(workflow) do
+        {:ok, _} -> all_errors
+        {:error, errors} -> all_errors ++ errors
+      end
+
+    # Execution readiness validation
+    all_errors =
+      case validate_execution_readiness(workflow) do
+        {:ok, _} -> all_errors
+        {:error, errors} -> all_errors ++ errors
+      end
+
+    if all_errors == [] do
+      Logger.info("Workflow validation successful: #{workflow.id}")
+      {:ok, workflow}
+    else
+      Logger.warning(
+        "Workflow validation failed with #{length(all_errors)} errors: #{inspect(all_errors)}"
+      )
+
+      {:error, all_errors}
+    end
+  end
+
+  @doc """
+  Validates basic workflow structure.
+  """
+  @spec validate_structure(Workflow.t()) :: {:ok, Workflow.t()} | {:error, [validation_error()]}
+  def validate_structure(%Workflow{nodes: []} = _workflow) do
+    {:error, [{:empty_workflow}]}
+  end
+
+  def validate_structure(%Workflow{} = workflow) do
+    errors = []
+
+    # Check for duplicate node IDs
+    node_ids = Enum.map(workflow.nodes, & &1.id)
+    duplicate_ids = node_ids -- Enum.uniq(node_ids)
+
+    errors =
+      if duplicate_ids == [] do
+        errors
+      else
+        duplicate_errors = Enum.map(duplicate_ids, fn id -> {:duplicate_node_id, id} end)
+        errors ++ duplicate_errors
+      end
+
+    # Check for duplicate connections
+    connections =
+      Enum.map(workflow.connections, fn conn ->
+        {conn.from.node, conn.from.port, conn.to.node, conn.to.port}
+      end)
+
+    duplicate_connections = connections -- Enum.uniq(connections)
+
+    errors =
+      if duplicate_connections == [] do
+        errors
+      else
+        duplicate_conn_errors =
+          Enum.map(duplicate_connections, fn {from_node, from_port, to_node, to_port} ->
+            {:duplicate_connection, "#{from_node}.#{from_port}", "#{to_node}.#{to_port}"}
+          end)
+
+        errors ++ duplicate_conn_errors
+      end
+
+    if errors == [] do
+      {:ok, workflow}
+    else
+      {:error, errors}
+    end
+  end
+
+  @doc """
+  Validates all nodes in the workflow.
+  """
+  @spec validate_nodes(Workflow.t()) :: {:ok, Workflow.t()} | {:error, [validation_error()]}
+  def validate_nodes(%Workflow{} = workflow) do
+    errors =
+      workflow.nodes
+      |> Enum.reject(& &1.disabled)
+      |> Enum.flat_map(&validate_single_node(&1, workflow))
+
+    if errors == [] do
+      {:ok, workflow}
+    else
+      {:error, errors}
+    end
+  end
+
+  @doc """
+  Validates a single node.
+  """
+  @spec validate_single_node(map(), Workflow.t()) :: [validation_error()]
+  def validate_single_node(node, _workflow) do
+    case Registry.get_metadata(node.type) do
+      {:ok, metadata} ->
+        validate_node_parameters(node, metadata)
+
+      {:error, :not_found} ->
+        [{:unknown_node_type, node.id, node.type}]
+    end
+  end
+
+  @doc """
+  Validates node parameters against metadata.
+  """
+  @spec validate_node_parameters(map(), map()) :: [validation_error()]
+  def validate_node_parameters(node, metadata) do
+    parameter_defs = Map.get(metadata, :parameters, [])
+
+    # Check required parameters
+    required_errors =
+      parameter_defs
+      |> Enum.filter(& &1[:required])
+      |> Enum.reject(fn param_def ->
+        Map.has_key?(node.parameters, param_def[:name])
+      end)
+      |> Enum.map(fn param_def ->
+        {:missing_required_parameter, node.id, param_def[:name]}
+      end)
+
+    # Validate parameter types and values
+    type_errors =
+      node.parameters
+      |> Enum.flat_map(fn {param_name, param_value} ->
+        case find_parameter_def(parameter_defs, param_name) do
+          nil ->
+            # Unknown parameter - could be a warning, but we'll allow it
+            []
+
+          param_def ->
+            validate_parameter_value(node.id, param_name, param_value, param_def)
+        end
+      end)
+
+    required_errors ++ type_errors
+  end
+
+  defp find_parameter_def(parameter_defs, param_name) do
+    Enum.find(parameter_defs, fn def -> def[:name] == param_name end)
+  end
+
+  defp validate_parameter_value(node_id, param_name, value, param_def) do
+    expected_type = param_def[:type]
+    options = param_def[:options]
+
+    cond do
+      # Check if value is in allowed options
+      options != nil and value not in options ->
+        [
+          {:invalid_parameter_value, node_id, param_name,
+           "Value must be one of: #{inspect(options)}"}
+        ]
+
+      # Type validation
+      not type_matches?(value, expected_type) ->
+        [{:invalid_parameter_type, node_id, param_name, expected_type, type_of(value)}]
+
+      # Additional validations based on type
+      expected_type == "number" and param_def[:min] != nil and value < param_def[:min] ->
+        [{:invalid_parameter_value, node_id, param_name, "Value must be >= #{param_def[:min]}"}]
+
+      expected_type == "number" and param_def[:max] != nil and value > param_def[:max] ->
+        [{:invalid_parameter_value, node_id, param_name, "Value must be <= #{param_def[:max]}"}]
+
+      expected_type == "string" and param_def[:pattern] != nil ->
+        pattern = Regex.compile!(param_def[:pattern])
+
+        if Regex.match?(pattern, value) do
+          []
+        else
+          [
+            {:invalid_parameter_value, node_id, param_name,
+             "Value must match pattern: #{param_def[:pattern]}"}
+          ]
+        end
+
+      true ->
+        []
+    end
+  end
+
+  defp type_matches?(value, expected_type) do
+    case expected_type do
+      "string" -> is_binary(value)
+      "number" -> is_number(value)
+      "boolean" -> is_boolean(value)
+      "array" -> is_list(value)
+      "object" -> is_map(value)
+      "integer" -> is_integer(value)
+      "float" -> is_float(value)
+      _ -> true
+    end
+  end
+
+  defp type_of(value) do
+    cond do
+      is_binary(value) -> "string"
+      is_integer(value) -> "integer"
+      is_float(value) -> "float"
+      is_boolean(value) -> "boolean"
+      is_list(value) -> "array"
+      is_map(value) -> "object"
+      true -> "unknown"
+    end
+  end
+
+  @doc """
+  Validates all connections in the workflow.
+  """
+  @spec validate_connections(Workflow.t()) :: {:ok, Workflow.t()} | {:error, [validation_error()]}
+  def validate_connections(%Workflow{} = workflow) do
+    errors = Enum.flat_map(workflow.connections, &validate_single_connection(&1, workflow))
+
+    if errors == [] do
+      {:ok, workflow}
+    else
+      {:error, errors}
+    end
+  end
+
+  @doc """
+  Validates a single connection.
+  """
+  @spec validate_single_connection(map(), Workflow.t()) :: [validation_error()]
+  def validate_single_connection(connection, workflow) do
+    from_node = find_node(workflow, connection.from.node)
+    to_node = find_node(workflow, connection.to.node)
+
+    cond do
+      from_node == nil ->
+        [{:connection_missing_from_node, connection.from.node}]
+
+      to_node == nil ->
+        [{:connection_missing_to_node, connection.to.node}]
+
+      from_node.disabled or to_node.disabled ->
+        # Skip validation for disabled nodes
+        []
+
+      true ->
+        validate_port_connection(from_node, to_node, connection)
+    end
+  end
+
+  defp find_node(workflow, node_id) do
+    Enum.find(workflow.nodes, fn n -> n.id == node_id end)
+  end
+
+  @doc """
+  Validates port compatibility between connected nodes.
+  """
+  @spec validate_port_connection(map(), map(), map()) :: [validation_error()]
+  def validate_port_connection(from_node, to_node, connection) do
+    with {:ok, from_metadata} <- Registry.get_metadata(from_node.type),
+         {:ok, to_metadata} <- Registry.get_metadata(to_node.type),
+         {:ok, output_port} <- find_port(from_metadata[:outputs], connection.from.port),
+         {:ok, input_port} <- find_port(to_metadata[:inputs], connection.to.port) do
+      case check_port_compatibility(output_port, input_port) do
+        :compatible ->
+          []
+
+        {:incompatible, reason} ->
+          [
+            {:incompatible_port_types, "#{from_node.id}.#{connection.from.port}",
+             "#{to_node.id}.#{connection.to.port}", reason}
+          ]
+      end
+    else
+      {:error, {:port_not_found, port_name}} when port_name == connection.from.port ->
+        [{:unknown_output_port, from_node.id, connection.from.port}]
+
+      {:error, {:port_not_found, port_name}} when port_name == connection.to.port ->
+        [{:unknown_input_port, to_node.id, connection.to.port}]
+
+      {:error, :not_found} ->
+        # Node type not found - should have been caught in node validation
+        []
+    end
+  end
+
+  defp find_port(ports, port_name) do
+    case Enum.find(ports, fn p -> p.name == port_name end) do
+      nil -> {:error, {:port_not_found, port_name}}
+      port -> {:ok, port}
+    end
+  end
+
+  @doc """
+  Checks if two port types are compatible.
+  """
+  @spec check_port_compatibility(map(), map()) :: compatibility_result()
+  def check_port_compatibility(output_port, input_port) do
+    output_type = output_port[:type]
+    input_type = input_port[:type]
+
+    cond do
+      # Any type is compatible with everything
+      output_type == :any or input_type == :any ->
+        :compatible
+
+      # Exact match
+      output_type == input_type ->
+        :compatible
+
+      # List compatibility
+      match?({:list, _}, output_type) and match?({:list, _}, input_type) ->
+        {:list, out_elem} = output_type
+        {:list, in_elem} = input_type
+        check_type_compatibility(out_elem, in_elem)
+
+      # Map compatibility
+      match?({:map, _}, output_type) and match?({:map, _}, input_type) ->
+        {:map, out_elem} = output_type
+        {:map, in_elem} = input_type
+        check_type_compatibility(out_elem, in_elem)
+
+      true ->
+        {:incompatible, "Type #{inspect(output_type)} cannot connect to #{inspect(input_type)}"}
+    end
+  end
+
+  defp check_type_compatibility(type1, type2) do
+    cond do
+      type1 == :any or type2 == :any -> :compatible
+      type1 == type2 -> :compatible
+      true -> {:incompatible, "Incompatible types: #{inspect(type1)} and #{inspect(type2)}"}
+    end
+  end
+
+  @doc """
+  Validates workflow topology (cycles, orphans, etc).
+  """
+  @spec validate_topology(Workflow.t()) :: {:ok, Workflow.t()} | {:error, [validation_error()]}
+  def validate_topology(%Workflow{} = workflow) do
+    errors = []
+
+    # Check for cycles
+    errors =
+      case detect_cycles(workflow) do
+        {:ok, :no_cycles} -> errors
+        {:error, {:cycle_detected, path}} -> [{:cycle_detected, path} | errors]
+      end
+
+    # Check for orphan nodes (except triggers)
+    orphan_errors = find_orphan_nodes(workflow)
+    errors = errors ++ orphan_errors
+
+    # Check for multiple inputs to same port
+    multi_input_errors = find_multiple_inputs_to_port(workflow)
+    errors = errors ++ multi_input_errors
+
+    if errors == [] do
+      {:ok, workflow}
+    else
+      {:error, errors}
+    end
+  end
+
+  # Helper function to determine if a node is a trigger
+  # Define this before it's used in other functions
+  defp trigger_node?(node) do
+    # Check against known trigger types
+    known_trigger_types = [
+      "gitlock.trigger.git_commits",
+      "gitlock.trigger.file_change",
+      "gitlock.trigger.webhook",
+      "gitlock.trigger.schedule"
+    ]
+
+    if node.type in known_trigger_types do
+      true
+    else
+      # Check if it's registered as a trigger via metadata
+      case Registry.get_metadata(node.type) do
+        {:ok, metadata} ->
+          # Node is a trigger if it has group "trigger"
+          Map.get(metadata, :group) == "trigger"
+
+        {:error, :not_found} ->
+          # If not found in registry, check if type contains "trigger"
+          String.contains?(node.type, "trigger")
+      end
+    end
+  end
+
+  @doc """
+  Detects cycles in the workflow graph using DFS.
+  """
+  @spec detect_cycles(Workflow.t()) ::
+          {:ok, :no_cycles} | {:error, {:cycle_detected, [String.t()]}}
+  def detect_cycles(%Workflow{} = workflow) do
+    graph = build_adjacency_list(workflow)
+    active_nodes = get_active_node_ids(workflow)
+
+    case dfs_detect_cycles(graph, active_nodes) do
+      nil -> {:ok, :no_cycles}
+      cycle_path -> {:error, {:cycle_detected, cycle_path}}
+    end
+  end
+
+  defp build_adjacency_list(workflow) do
+    workflow.connections
+    |> Enum.filter(fn conn ->
+      from_node = find_node(workflow, conn.from.node)
+      to_node = find_node(workflow, conn.to.node)
+      from_node && to_node && !from_node.disabled && !to_node.disabled
+    end)
+    |> Enum.reduce(%{}, fn conn, acc ->
+      Map.update(acc, conn.from.node, [conn.to.node], fn existing ->
+        [conn.to.node | existing]
+      end)
+    end)
+  end
+
+  defp get_active_node_ids(workflow) do
+    workflow.nodes
+    |> Enum.reject(& &1.disabled)
+    |> Enum.map(& &1.id)
+  end
+
+  defp dfs_detect_cycles(graph, nodes) do
+    initial_state = %{
+      visited: MapSet.new(),
+      rec_stack: MapSet.new(),
+      parent_map: %{}
+    }
+
+    Enum.find_value(nodes, fn node ->
+      if node not in initial_state.visited do
+        dfs_visit(node, graph, initial_state)
+      end
+    end)
+  end
+
+  defp dfs_visit(node, graph, state) do
+    state = %{
+      state
+      | visited: MapSet.put(state.visited, node),
+        rec_stack: MapSet.put(state.rec_stack, node)
+    }
+
+    neighbors = Map.get(graph, node, [])
+
+    result =
+      Enum.find_value(neighbors, fn neighbor ->
+        cond do
+          neighbor in state.rec_stack ->
+            # Found a cycle - reconstruct path
+            reconstruct_cycle_path(neighbor, node, state.parent_map)
+
+          neighbor not in state.visited ->
+            new_state = %{state | parent_map: Map.put(state.parent_map, neighbor, node)}
+            dfs_visit(neighbor, graph, new_state)
+
+          true ->
+            nil
+        end
+      end)
+
+    if result do
+      result
+    else
+      # Remove from recursion stack when backtracking
+      nil
+    end
+  end
+
+  defp reconstruct_cycle_path(cycle_start, current, parent_map) do
+    # Build path from current back to cycle_start
+    path = build_path_to_cycle_start(current, cycle_start, parent_map, [current])
+
+    # The path is built backwards, so reverse it and add cycle_start at the end to close the cycle
+    reversed_path = Enum.reverse(path)
+
+    # Only add cycle_start at the beginning if it's not already there
+    final_path =
+      if List.first(reversed_path) == cycle_start do
+        reversed_path
+      else
+        [cycle_start | reversed_path]
+      end
+
+    # Add cycle_start at the end to show the cycle
+    final_path ++ [cycle_start]
+  end
+
+  defp build_path_to_cycle_start(current, cycle_start, parent_map, acc) do
+    case Map.get(parent_map, current) do
+      nil ->
+        # No parent, shouldn't happen in a proper cycle
+        acc
+
+      ^cycle_start ->
+        # Found the cycle start, add it to path
+        [cycle_start | acc]
+
+      parent ->
+        # Continue building path
+        build_path_to_cycle_start(parent, cycle_start, parent_map, [parent | acc])
+    end
+  end
+
+  @doc """
+  Finds orphan nodes (nodes with no connections except triggers).
+  """
+  @spec find_orphan_nodes(Workflow.t()) :: [validation_error()]
+  def find_orphan_nodes(%Workflow{} = workflow) do
+    workflow.nodes
+    |> Enum.reject(& &1.disabled)
+    |> Enum.filter(fn node ->
+      is_trigger = trigger_node?(node)
+      has_incoming = Enum.any?(workflow.connections, fn c -> c.to.node == node.id end)
+      has_outgoing = Enum.any?(workflow.connections, fn c -> c.from.node == node.id end)
+
+      not is_trigger and not has_incoming and not has_outgoing
+    end)
+    |> Enum.map(fn node -> {:orphan_node, node.id} end)
+  end
+
+  @doc """
+  Finds ports that have multiple incoming connections.
+  """
+  @spec find_multiple_inputs_to_port(Workflow.t()) :: [validation_error()]
+  def find_multiple_inputs_to_port(%Workflow{} = workflow) do
+    workflow.connections
+    |> Enum.group_by(fn conn -> {conn.to.node, conn.to.port} end)
+    |> Enum.filter(fn {_key, conns} -> length(conns) > 1 end)
+    |> Enum.map(fn {{node_id, port}, _conns} ->
+      {:multiple_inputs_to_port, node_id, port}
+    end)
+  end
+
+  @doc """
+  Validates that the workflow is ready for execution.
+  """
+  @spec validate_execution_readiness(Workflow.t()) ::
+          {:ok, Workflow.t()} | {:error, [validation_error()]}
+  def validate_execution_readiness(%Workflow{} = workflow) do
+    errors = []
+
+    active_triggers =
+      workflow.nodes
+      |> Enum.filter(fn node ->
+        trigger_node?(node)
+      end)
+
+    errors =
+      if active_triggers == [] do
+        [{:no_trigger_nodes} | errors]
+      else
+        errors
+      end
+
+    # Check required inputs are connected
+    required_input_errors = check_required_inputs_connected(workflow)
+    errors = errors ++ required_input_errors
+
+    # Check for disabled nodes in critical paths
+    disabled_critical_errors = check_disabled_nodes_in_critical_paths(workflow)
+    errors = errors ++ disabled_critical_errors
+
+    if errors == [] do
+      {:ok, workflow}
+    else
+      {:error, errors}
+    end
+  end
+
+  defp check_required_inputs_connected(workflow) do
+    workflow.nodes
+    |> Enum.reject(& &1.disabled)
+    |> Enum.flat_map(fn node ->
+      case Registry.get_metadata(node.type) do
+        {:ok, metadata} ->
+          required_inputs =
+            metadata[:inputs]
+            |> Enum.filter(& &1[:required])
+            |> Enum.map(& &1[:name])
+
+          connected_inputs =
+            workflow.connections
+            |> Enum.filter(fn conn -> conn.to.node == node.id end)
+            |> Enum.map(fn conn -> conn.to.port end)
+
+          missing_inputs = required_inputs -- connected_inputs
+
+          Enum.map(missing_inputs, fn input ->
+            {:required_input_not_connected, node.id, input}
+          end)
+
+        {:error, _} ->
+          []
+      end
+    end)
+  end
+
+  defp check_disabled_nodes_in_critical_paths(workflow) do
+    # Find paths from triggers to outputs
+    # If any disabled node blocks all paths, it's a critical error
+
+    # For now, simple check: warn if disabled node has active connections
+    workflow.nodes
+    |> Enum.filter(fn node ->
+      has_active_incoming =
+        Enum.any?(workflow.connections, fn conn ->
+          conn.to.node == node.id and
+            case find_node(workflow, conn.from.node) do
+              nil -> false
+              from_node -> not from_node.disabled
+            end
+        end)
+
+      has_active_outgoing =
+        Enum.any?(workflow.connections, fn conn ->
+          conn.from.node == node.id and
+            case find_node(workflow, conn.to.node) do
+              nil -> false
+              to_node -> not to_node.disabled
+            end
+        end)
+
+      has_active_incoming and has_active_outgoing and node.disabled
+    end)
+    |> Enum.map(fn node -> {:disabled_node_in_critical_path, node.id} end)
+  end
+
+  @doc """
+  Validates that two nodes can be connected on specific ports.
+
+  This is useful for real-time validation in the UI.
+
+  ## Examples
+
+      iex> Validator.validate_connection(workflow, "node1", "output", "node2", "input")
+      :ok
+
+      iex> Validator.validate_connection(workflow, "node1", "output", "node2", "input")
+      {:error, {:incompatible_port_types, "string", "number"}}
+  """
+  @spec validate_connection(Workflow.t(), String.t(), String.t(), String.t(), String.t()) ::
+          :ok | {:error, validation_error()}
+  def validate_connection(workflow, from_node_id, from_port, to_node_id, to_port) do
+    from_node = find_node(workflow, from_node_id)
+    to_node = find_node(workflow, to_node_id)
+
+    cond do
+      from_node == nil ->
+        {:error, {:connection_missing_from_node, from_node_id}}
+
+      to_node == nil ->
+        {:error, {:connection_missing_to_node, to_node_id}}
+
+      true ->
+        connection = %{
+          from: %{node: from_node_id, port: from_port},
+          to: %{node: to_node_id, port: to_port}
+        }
+
+        case validate_port_connection(from_node, to_node, connection) do
+          [] -> :ok
+          [error | _] -> {:error, error}
+        end
+    end
+  end
+
+  @doc """
+  Validates a workflow and returns a formatted error report.
+
+  Useful for debugging validation issues.
+
+  ## Examples
+
+      iex> Validator.validate_and_report(workflow)
+      {:ok, workflow}
+      
+      iex> Validator.validate_and_report(invalid_workflow)
+      {:error, 
+       \"\"\"
+       Workflow validation failed with 3 errors:
+       1. Node 'node_1' has unknown type 'invalid.type'
+       2. Node 'node_2' is missing required parameter 'threshold'
+       3. No trigger nodes found in workflow
+       \"\"\"}
+  """
+  @spec validate_and_report(Workflow.t()) :: {:ok, Workflow.t()} | {:error, String.t()}
+  def validate_and_report(%Workflow{} = workflow) do
+    case validate_workflow(workflow) do
+      {:ok, workflow} ->
+        {:ok, workflow}
+
+      {:error, errors} ->
+        report = format_validation_errors(errors)
+        {:error, report}
+    end
+  end
+
+  @doc """
+  Formats validation errors into a human-readable report.
+  """
+  @spec format_validation_errors([validation_error()]) :: String.t()
+  def format_validation_errors(errors) do
+    header = "Workflow validation failed with #{length(errors)} error(s):\n"
+
+    formatted_errors =
+      errors
+      |> Enum.with_index(1)
+      |> Enum.map_join("\n", fn {error, index} ->
+        "#{index}. #{format_single_error(error)}"
+      end)
+
+    header <> formatted_errors
+  end
+
+  defp format_single_error(error) do
+    case error do
+      {:unknown_node_type, node_id, type} ->
+        "Node '#{node_id}' has unknown type '#{type}'"
+
+      {:missing_required_parameter, node_id, param} ->
+        "Node '#{node_id}' is missing required parameter '#{param}'"
+
+      {:invalid_parameter_type, node_id, param, expected, actual} ->
+        "Node '#{node_id}' parameter '#{param}' has wrong type: expected #{expected}, got #{actual}"
+
+      {:invalid_parameter_value, node_id, param, reason} ->
+        "Node '#{node_id}' parameter '#{param}' has invalid value: #{reason}"
+
+      {:connection_missing_from_node, node_id} ->
+        "Connection references non-existent source node '#{node_id}'"
+
+      {:connection_missing_to_node, node_id} ->
+        "Connection references non-existent target node '#{node_id}'"
+
+      {:unknown_output_port, node_id, port} ->
+        "Node '#{node_id}' does not have output port '#{port}'"
+
+      {:unknown_input_port, node_id, port} ->
+        "Node '#{node_id}' does not have input port '#{port}'"
+
+      {:incompatible_port_types, from, to, reason} ->
+        "Cannot connect #{from} to #{to}: #{reason}"
+
+      {:cycle_detected, path} ->
+        "Cycle detected: #{Enum.join(path, " -> ")}"
+
+      {:orphan_node, node_id} ->
+        "Node '#{node_id}' is not connected to any other nodes"
+
+      {:duplicate_node_id, node_id} ->
+        "Duplicate node ID '#{node_id}'"
+
+      {:duplicate_connection, from, to} ->
+        "Duplicate connection from #{from} to #{to}"
+
+      {:empty_workflow} ->
+        "Workflow has no nodes"
+
+      {:no_trigger_nodes} ->
+        "Workflow has no trigger nodes"
+
+      {:multiple_inputs_to_port, node_id, port} ->
+        "Node '#{node_id}' port '#{port}' has multiple incoming connections"
+
+      {:required_input_not_connected, node_id, port} ->
+        "Node '#{node_id}' required input port '#{port}' is not connected"
+
+      {:disabled_node_in_critical_path, node_id} ->
+        "Disabled node '#{node_id}' is blocking workflow execution"
+
+      other ->
+        inspect(other)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime/workflow.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/workflow.ex
new file mode 100644
index 0000000..4cd9883
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime/workflow.ex
@@ -0,0 +1,386 @@
+defmodule GitlockWorkflows.Runtime.Workflow do
+  @moduledoc """
+  Workflow data structure and Reactor conversion.
+
+  This module: 
+  - Define the workflow structure compatible with n8n format
+  - Converts between JSON and internal representation
+  - Transforms workflows into executable Reactor instances
+  """
+  require Logger
+
+  alias Reactor.{Builder, Argument, Template}
+
+  @type node_definition :: %{
+          id: String.t(),
+          type: String.t(),
+          position: [number()],
+          parameters: map(),
+          disabled: boolean()
+        }
+
+  @type connection :: %{
+          from: %{node: String.t(), port: String.t()},
+          to: %{node: String.t(), port: String.t()}
+        }
+
+  @type t :: %__MODULE__{
+          id: String.t(),
+          name: String.t(),
+          description: String.t() | nil,
+          nodes: [node_definition()],
+          connections: [connection()],
+          settings: map(),
+          reactor: Reactor.t() | nil,
+          repo_path: String.t() | nil,
+          version: integer()
+        }
+
+  defstruct [
+    :id,
+    :name,
+    :description,
+    :nodes,
+    :connections,
+    :settings,
+    :reactor,
+    :repo_path,
+    version: 1
+  ]
+
+  @doc """
+  Parse workflow from n8n-compatible JSON format. 
+
+  ## Example 
+      iex> json = ~s({"name": "My Workflow", "nodes": [], "connections": []})
+      iex> {:ok, workflow} = Workflow.from_json(json)
+      iex> workflow.name
+      "My Workflow"
+  """
+  @spec from_json(String.t()) :: {:ok, t()} | {:error, term()}
+  def from_json(json) when is_binary(json) do
+    with {:ok, data} <- Jason.decode(json),
+         {:ok, workflow} <- parse_workflow_data(data) do
+      {:ok, workflow}
+    else
+      {:error, %Jason.DecodeError{} = error} ->
+        {:error, {:invalid_json, error}}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  defp parse_workflow_data(data) when is_map(data) do
+    workflow = %__MODULE__{
+      id: data["id"] || generate_workflow_id(),
+      name: data["name"] || "Untitled Workflow",
+      description: data["description"],
+      nodes: parse_nodes(data["nodes"] || []),
+      connections: parse_connections(data["connections"] || []),
+      settings: data["settings"] || %{},
+      version: data["version"] || 1
+    }
+
+    {:ok, workflow}
+  rescue
+    e -> {:error, {:parse_error, Exception.message(e)}}
+  end
+
+  defp generate_workflow_id do
+    "wf_" <> (:crypto.strong_rand_bytes(8) |> Base.url_encode64(padding: false))
+  end
+
+  defp parse_nodes(nodes) when is_list(nodes) do
+    Enum.map(nodes, fn node ->
+      %{
+        id: node["id"] || raise("Node missing id"),
+        type: node["type"] || raise("Node missing type"),
+        position: node["position"] || [0, 0],
+        parameters: node["parameters"] || %{},
+        disabled: node["disabled"] || false
+      }
+    end)
+  end
+
+  defp parse_connections(connections) when is_list(connections) do
+    Enum.map(connections, fn conn ->
+      %{
+        from: %{
+          node: get_in(conn, ["from", "node"]) || raise("Connection missing from.node"),
+          port: get_in(conn, ["from", "output"]) || "main"
+        },
+        to: %{
+          node: get_in(conn, ["to", "node"]) || raise("Connection missing to.node"),
+          port: get_in(conn, ["to", "input"]) || "main"
+        }
+      }
+    end)
+  end
+
+  @doc """
+  Convert workflow to n8n-compatible JSON format.
+  """
+  @spec to_json(t()) :: {:ok, String.t()} | {:error, term()}
+  def to_json(%__MODULE__{} = workflow) do
+    data = %{
+      "id" => workflow.id,
+      "name" => workflow.name,
+      "description" => workflow.description,
+      "nodes" => serialize_nodes(workflow.nodes),
+      "connections" => serialize_connections(workflow.connections),
+      "settings" => workflow.settings,
+      "version" => workflow.version
+    }
+
+    case Jason.encode(data) do
+      {:ok, json} -> {:ok, json}
+      {:error, error} -> {:error, {:encode_error, error}}
+    end
+  end
+
+  defp serialize_nodes(nodes) do
+    Enum.map(nodes, fn node ->
+      %{
+        "id" => node[:id] || node.id,
+        "type" => node[:type] || node.type,
+        "position" => node[:position] || node.position || [0, 0],
+        "parameters" => node[:parameters] || node.parameters || %{},
+        "disabled" => node[:disabled] || node.disabled || false
+      }
+    end)
+  end
+
+  defp serialize_connections(connections) do
+    Enum.map(connections, fn conn ->
+      %{
+        "from" => %{
+          "node" => conn.from.node,
+          "output" => conn.from.port
+        },
+        "to" => %{
+          "node" => conn.to.node,
+          "input" => conn.to.port
+        }
+      }
+    end)
+  end
+
+  @spec to_reactor(t()) :: {:ok, t()} | {:error, term()}
+  def to_reactor(%__MODULE__{nodes: []}), do: {:error, :empty_workflow}
+
+  def to_reactor(%__MODULE__{} = workflow) do
+    Logger.info("Converting workflow #{workflow.id} to Reactor")
+
+    case build_reactor_from_workflow(workflow) do
+      {:ok, reactor} ->
+        {:ok, %{workflow | reactor: reactor}}
+
+      {:error, reason} ->
+        Logger.error("Failed to convert workflow to Reactor: #{inspect(reason)}")
+        {:error, reason}
+    end
+  end
+
+  defp build_reactor_from_workflow(workflow) do
+    reactor = Reactor.Builder.new()
+
+    # Don't add inputs - just add steps
+    with {:ok, reactor} <- add_workflow_steps(reactor, workflow),
+         {:ok, reactor} <- add_workflow_return(reactor, workflow) do
+      {:ok, reactor}
+    end
+  rescue
+    e -> {:error, {:reactor_build_error, Exception.message(e)}}
+  end
+
+  defp add_workflow_steps(reactor, workflow) do
+    workflow.nodes
+    |> Enum.reject(& &1.disabled)
+    |> Enum.reduce_while({:ok, reactor}, fn node, {:ok, acc} ->
+      case add_single_step(acc, node, workflow) do
+        {:ok, new_r} -> {:cont, {:ok, new_r}}
+        err -> {:halt, err}
+      end
+    end)
+  end
+
+  defp add_single_step(reactor, %{id: id, type: type, parameters: parameters} = node, workflow) do
+    step_name = String.to_atom(id)
+    args = build_step_arguments(node, workflow)
+
+    # Pass parameters directly in the step context
+    # Reactor will merge this into the execution context
+    step_options = [
+      context: %{
+        parameters: parameters || %{}
+      }
+    ]
+
+    case GitlockWorkflows.Runtime.Registry.get_node(type) do
+      {:ok, mod} ->
+        Reactor.Builder.add_step(reactor, step_name, mod, args, step_options)
+
+      {:error, :not_found} ->
+        {:error, {:unknown_node_type, id, type}}
+    end
+  end
+
+  defp build_step_arguments(node, workflow) do
+    incoming_connections =
+      workflow.connections
+      |> Enum.filter(fn conn -> conn.to.node == node.id end)
+
+    if incoming_connections == [] do
+      # Trigger nodes have no arguments
+      []
+    else
+      # Build arguments from connections
+      Enum.map(incoming_connections, fn conn ->
+        %Reactor.Argument{
+          name: String.to_atom(conn.to.port),
+          source: %Reactor.Template.Result{
+            name: String.to_atom(conn.from.node),
+            sub_path: [String.to_atom(conn.from.port)]
+          }
+        }
+      end)
+    end
+  end
+
+  defp add_workflow_return(reactor, workflow) do
+    return_id = find_return_step(workflow) || List.first(workflow.nodes).id
+    Reactor.Builder.return(reactor, String.to_atom(return_id))
+  end
+
+  defp find_return_step(workflow) do
+    workflow.nodes
+    |> Enum.reject(& &1.disabled)
+    |> Enum.find_value(fn node ->
+      if not Enum.any?(workflow.connections, &(&1.from.node == node.id)), do: node.id
+    end)
+  end
+
+  @doc """
+  Add a node to the workflow.
+  """
+  @spec add_node(t(), node_definition() | map()) :: t()
+  def add_node(%__MODULE__{} = workflow, node) do
+    # Convert to map if needed
+    node_map = if is_struct(node), do: Map.from_struct(node), else: node
+
+    # Validate node has required fields
+    unless node_map[:id] && node_map[:type] do
+      raise ArgumentError, "Node must have id and type"
+    end
+
+    # Check for duplicate ID
+    if Enum.any?(workflow.nodes, fn n -> n.id == node_map[:id] end) do
+      raise ArgumentError, "Node with id #{node_map[:id]} already exists"
+    end
+
+    %{
+      workflow
+      | nodes: workflow.nodes ++ [normalize_node(node_map)],
+        # Clear reactor as workflow changed
+        reactor: nil
+    }
+  end
+
+  @doc """
+  Add a connection between nodes.
+  """
+  @spec add_connection(t(), String.t(), String.t(), keyword()) :: {:ok, t()} | {:error, term()}
+  def add_connection(%__MODULE__{} = workflow, from_node_id, to_node_id, opts \\ []) do
+    from_port = Keyword.get(opts, :from_port, "main")
+    to_port = Keyword.get(opts, :to_port, "main")
+
+    # Validate nodes exist
+    cond do
+      not node_exists?(workflow, from_node_id) ->
+        {:error, {:node_not_found, from_node_id}}
+
+      not node_exists?(workflow, to_node_id) ->
+        {:error, {:node_not_found, to_node_id}}
+
+      true ->
+        connection = %{
+          from: %{node: from_node_id, port: from_port},
+          to: %{node: to_node_id, port: to_port}
+        }
+
+        # Check for duplicate connection
+        if connection_exists?(workflow, connection) do
+          {:error, :connection_already_exists}
+        else
+          updated_workflow = %{
+            workflow
+            | connections: workflow.connections ++ [connection],
+              reactor: nil
+          }
+
+          {:ok, updated_workflow}
+        end
+    end
+  end
+
+  defp normalize_node(node) do
+    %{
+      id: node[:id] || node["id"],
+      type: node[:type] || node["type"],
+      position: node[:position] || node["position"] || [0, 0],
+      parameters: node[:parameters] || node["parameters"] || %{},
+      disabled: node[:disabled] || node["disabled"] || false
+    }
+  end
+
+  defp node_exists?(workflow, node_id) do
+    Enum.any?(workflow.nodes, fn n -> n.id == node_id end)
+  end
+
+  defp connection_exists?(workflow, connection) do
+    Enum.any?(workflow.connections, fn c ->
+      c.from.node == connection.from.node &&
+        c.from.port == connection.from.port &&
+        c.to.node == connection.to.node &&
+        c.to.port == connection.to.port
+    end)
+  end
+
+  @doc """
+  Get all nodes of a specific type.
+  """
+  @spec get_nodes_by_type(t(), String.t()) :: [node_definition()]
+  def get_nodes_by_type(%__MODULE__{} = workflow, type) do
+    Enum.filter(workflow.nodes, fn node -> node.type == type end)
+  end
+
+  @doc """
+  Get node by ID.
+  """
+  @spec get_node(t(), String.t()) :: node_definition() | nil
+  def get_node(%__MODULE__{} = workflow, node_id) do
+    Enum.find(workflow.nodes, fn node -> node.id == node_id end)
+  end
+
+  @doc """
+  Get all connections for a node.
+  """
+  @spec get_node_connections(t(), String.t()) :: %{
+          inputs: [connection()],
+          outputs: [connection()]
+        }
+  def get_node_connections(%__MODULE__{} = workflow, node_id) do
+    %{
+      inputs: Enum.filter(workflow.connections, fn c -> c.to.node == node_id end),
+      outputs: Enum.filter(workflow.connections, fn c -> c.from.node == node_id end)
+    }
+  end
+
+  @doc """
+  Check if workflow has been converted to Reactor.
+  """
+  @spec reactor_ready?(t()) :: boolean()
+  def reactor_ready?(%__MODULE__{reactor: nil}), do: false
+  def reactor_ready?(%__MODULE__{reactor: _}), do: true
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/runtime_supervisor.ex b/apps/gitlock_workflows/lib/gitlock_workflows/runtime_supervisor.ex
new file mode 100644
index 0000000..7504823
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/runtime_supervisor.ex
@@ -0,0 +1,56 @@
+defmodule GitlockWorkflows.RuntimeSupervisor do
+  @moduledoc """
+  Supervisor for the GitlockWorkflows Runtime system.
+
+  Manages the lifecycle of runtime components including:
+  - Registry for node registration and discovery
+  - Engine for workflow execution
+  - Any other runtime services
+  """
+  use Supervisor
+
+  def start_link(init_arg) do
+    Supervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
+  end
+
+  @impl true
+  def init(_init_arg) do
+    children = [
+      # Start the Registry first as other components depend on it
+      {GitlockWorkflows.Runtime.Registry, []},
+
+      # Start the Engine for workflow execution
+      {GitlockWorkflows.Runtime.Engine, []}
+
+      # Add other runtime components here as needed
+      # {GitlockWorkflows.Runtime.Scheduler, []},
+      # {GitlockWorkflows.Runtime.Monitor, []},
+    ]
+
+    # Restart strategy: if one crashes, restart only that one
+    # Max 3 restarts within 5 seconds
+    Supervisor.init(children, strategy: :one_for_one, max_restarts: 3, max_seconds: 5)
+  end
+
+  @doc """
+  Registers all built-in nodes after the supervisor starts.
+
+  This should be called from your application's start callback:
+
+      def start(_type, _args) do
+        children = [
+          GitlockWorkflows.RuntimeSupervisor
+        ]
+        
+        opts = [strategy: :one_for_one, name: GitlockWorkflows.Supervisor]
+        
+        with {:ok, pid} <- Supervisor.start_link(children, opts) do
+          GitlockWorkflows.RuntimeSupervisor.register_builtin_nodes()
+          {:ok, pid}
+        en
+      end
+  """
+  def register_builtin_nodes do
+    GitlockWorkflows.Runtime.Registry.register_builtin_nodes()
+  end
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/serializer.ex b/apps/gitlock_workflows/lib/gitlock_workflows/serializer.ex
new file mode 100644
index 0000000..6c3e549
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/serializer.ex
@@ -0,0 +1,88 @@
+defmodule GitlockWorkflows.Serializer do
+  @moduledoc """
+  Serializes workflow domain structs for the SvelteFlow UI layer.
+  """
+
+  alias GitlockWorkflows.{Pipeline, Node, Edge, Port, NodeCatalog}
+
+  @doc "Serializes a Pipeline to a map ready for JSON encoding."
+  @spec to_map(Pipeline.t()) :: map()
+  def to_map(%Pipeline{} = pipeline) do
+    %{
+      id: pipeline.id,
+      name: pipeline.name,
+      nodes: Map.new(pipeline.nodes, fn {id, node} -> {id, node_to_map(node)} end),
+      edges: Map.new(pipeline.edges, fn {id, edge} -> {id, edge_to_map(edge)} end)
+    }
+  end
+
+  @doc "Serializes the node catalog grouped by category for the palette UI."
+  @spec catalog_to_list() :: [map()]
+  def catalog_to_list do
+    NodeCatalog.list_types()
+    |> Enum.group_by(& &1.category)
+    |> Enum.sort_by(fn {cat, _} -> category_order(cat) end)
+    |> Enum.map(fn {category, types} ->
+      %{
+        name: category_label(category),
+        types:
+          Enum.map(types, fn type_def ->
+            %{
+              type_id: type_def.type_id,
+              label: type_def.label,
+              description: type_def.description,
+              category: type_def.category,
+              config_schema: Map.get(type_def, :config_schema, [])
+            }
+          end)
+          |> Enum.sort_by(& &1.label)
+      }
+    end)
+  end
+
+  defp node_to_map(%Node{} = node) do
+    {:ok, type_def} = NodeCatalog.get_type(node.type)
+    {x, y} = node.position
+
+    %{
+      id: node.id,
+      type: node.type,
+      label: node.label,
+      category: type_def.category,
+      position: [x, y],
+      config: node.config,
+      config_schema: Map.get(type_def, :config_schema, []),
+      input_ports: Enum.map(node.input_ports, &port_to_map/1),
+      output_ports: Enum.map(node.output_ports, &port_to_map/1)
+    }
+  end
+
+  defp edge_to_map(%Edge{} = edge) do
+    %{
+      id: edge.id,
+      source_node_id: edge.source_node_id,
+      source_port_id: edge.source_port_id,
+      target_node_id: edge.target_node_id,
+      target_port_id: edge.target_port_id
+    }
+  end
+
+  defp port_to_map(%Port{} = port) do
+    map = %{id: port.id, name: port.name, data_type: port.data_type}
+    if port.optional, do: Map.put(map, :optional, true), else: map
+  end
+
+  defp category_label(:source), do: "Sources"
+  defp category_label(:filter), do: "Filters"
+  defp category_label(:analyze), do: "Analyzers"
+  defp category_label(:logic), do: "Logic"
+  defp category_label(:output), do: "Outputs"
+  defp category_label(other), do: to_string(other) |> String.capitalize()
+
+  defp category_order(:source), do: 0
+  defp category_order(:analyze), do: 1
+  defp category_order(:logic), do: 2
+  defp category_order(:filter), do: 3
+  defp category_order(:output), do: 4
+  defp category_order(_), do: 5
+end
diff --git a/apps/gitlock_workflows/lib/gitlock_workflows/templates.ex b/apps/gitlock_workflows/lib/gitlock_workflows/templates.ex
new file mode 100644
index 0000000..7a7b2eb
--- /dev/null
+++ b/apps/gitlock_workflows/lib/gitlock_workflows/templates.ex
@@ -0,0 +1,310 @@
+defmodule GitlockWorkflows.Templates do
+  @moduledoc """
+  Pre-built pipeline templates for common analysis patterns.
+
+  Each template returns a fully wired `%Pipeline{}` ready to execute.
+  Templates are the single source of truth — `GitlockPhx.Pipelines.seed_templates!/0`
+  delegates here for database seeding.
+  """
+
+  alias GitlockWorkflows.{Pipeline, Node, Edge}
+
+  @type template_info :: %{
+          id: atom(),
+          name: String.t(),
+          description: String.t()
+        }
+
+  @doc "Lists available templates with metadata."
+  @spec list() :: [template_info()]
+  def list do
+    [
+      %{
+        id: :full_analysis,
+        name: "Full Analysis",
+        description: "Complete codebase health analysis with all analyzers"
+      },
+      %{
+        id: :hotspot_scan,
+        name: "Hotspot Quick Scan",
+        description: "Find high-risk files fast"
+      },
+      %{
+        id: :knowledge_risk,
+        name: "Knowledge Risk Assessment",
+        description: "Identify bus factor risks and coupling patterns"
+      },
+      %{
+        id: :codebase_intelligence,
+        name: "Codebase Intelligence Report",
+        description:
+          "Advanced multi-stage pipeline: analyzes hotspots, couplings, knowledge silos, and code age, " <>
+            "then filters, sorts, groups, aggregates, and merges results into actionable findings"
+      }
+    ]
+  end
+
+  @doc "Builds a pipeline from a template id."
+  @spec build(atom()) :: Pipeline.t() | {:error, :unknown_template}
+  def build(:full_analysis), do: full_analysis()
+  def build(:hotspot_scan), do: hotspot_scan()
+  def build(:knowledge_risk), do: knowledge_risk()
+  def build(:codebase_intelligence), do: codebase_intelligence()
+  # Keep old names as aliases for backward compatibility
+  def build(:team_health), do: knowledge_risk()
+  def build(_), do: {:error, :unknown_template}
+
+  # ── Full Analysis ────────────────────────────────────────────
+
+  defp full_analysis do
+    git = Node.new(:git_log, position: {100, 300})
+    hotspots = Node.new(:hotspot_detection, position: {380, 80})
+    couplings = Node.new(:coupling_detection, position: {380, 200})
+    silos = Node.new(:knowledge_silo_detection, position: {380, 320})
+    age = Node.new(:code_age_analysis, position: {380, 440})
+    blast = Node.new(:blast_radius_analysis, position: {380, 560})
+    coupled = Node.new(:coupled_hotspot_analysis, position: {380, 680})
+    summary_node = Node.new(:summary, position: {700, 300})
+
+    Pipeline.new("Full Analysis",
+      description: "Complete codebase health analysis with all analyzers"
+    )
+    |> add_nodes([git, hotspots, couplings, silos, age, blast, coupled, summary_node])
+    |> connect(git, hotspots)
+    |> connect(git, couplings)
+    |> connect(git, silos)
+    |> connect(git, age)
+    |> connect(git, blast)
+    |> connect(git, coupled)
+    |> connect(git, summary_node)
+  end
+
+  # ── Hotspot Quick Scan ───────────────────────────────────────
+
+  defp hotspot_scan do
+    git = Node.new(:git_log, position: {100, 200})
+    hotspots = Node.new(:hotspot_detection, position: {380, 200})
+    summary_node = Node.new(:summary, position: {380, 340})
+
+    Pipeline.new("Hotspot Quick Scan", description: "Find high-risk files fast")
+    |> add_nodes([git, hotspots, summary_node])
+    |> connect(git, hotspots)
+    |> connect(git, summary_node)
+  end
+
+  # ── Knowledge Risk Assessment ────────────────────────────────
+
+  defp knowledge_risk do
+    git = Node.new(:git_log, position: {100, 250})
+    silos = Node.new(:knowledge_silo_detection, position: {380, 160})
+    couplings = Node.new(:coupling_detection, position: {380, 340})
+    summary_node = Node.new(:summary, position: {660, 250})
+
+    Pipeline.new("Knowledge Risk Assessment",
+      description: "Identify bus factor risks and coupling patterns"
+    )
+    |> add_nodes([git, silos, couplings, summary_node])
+    |> connect(git, silos)
+    |> connect(git, couplings)
+    |> connect(git, summary_node)
+  end
+
+  # ── Codebase Intelligence Report ─────────────────────────────
+  #
+  #  An advanced pipeline using every logic node type.
+  #
+  #  ┌─────────────────── HOTSPOT PATH ────────────────────────────────┐
+  #  │ Hotspots → IF(revisions≥50) ──true──→ Sort(risk desc) → Limit(20)──→ Merge.a ──→ (combined)
+  #  │                              ──false─→ Aggregate(stats)              ↑
+  #  │                                                                     │
+  #  ├─────────────────── COUPLING PATH ───────────────────────────────│
+  #  │ Couplings → Filter(degree>2) ──kept─→ RemoveDups → Sort → Limit(15)→ Merge.b
+  #  │                                                                     │
+  #  ├─────────────────── KNOWLEDGE PATH ──────────────────────────────│
+  #  │ Silos → GroupBy(main_author)                                       │
+  #  │                                                                     │
+  #  ├─────────────────── CODE AGE PATH ───────────────────────────────│
+  #  │ Code Age → Switch(risk_factor: high,medium,low)                    │
+  #  │             case_0(high) → Sort(last_modified) → Limit(10)         │
+  #  │                                                                     │
+  #  └─────────────────── SUMMARY ─────────────────────────────────────┘
+  #    Summary
+  #
+
+  defp codebase_intelligence do
+    # Column 1 (x=80): Source
+    git = Node.new(:git_log, position: {80, 360})
+
+    # Column 2 (x=380): Analyzers
+    hotspots = Node.new(:hotspot_detection, position: {380, 60})
+    couplings = Node.new(:coupling_detection, position: {380, 240})
+    silos = Node.new(:knowledge_silo_detection, position: {380, 440})
+    age = Node.new(:code_age_analysis, position: {380, 600})
+    summary_node = Node.new(:summary, position: {380, 760})
+
+    # Column 3 (x=700): First logic stage
+    if_node =
+      Node.new(:if_condition,
+        position: {700, 60},
+        config: %{"field" => "revisions", "operator" => "gte", "value" => "50"}
+      )
+
+    filter_node =
+      Node.new(:filter,
+        position: {700, 240},
+        config: %{"field" => "degree", "operator" => "gt", "value" => "2"}
+      )
+
+    group_node =
+      Node.new(:group_by,
+        position: {700, 440},
+        config: %{"field" => "main_author"}
+      )
+
+    switch_node =
+      Node.new(:switch,
+        position: {700, 600},
+        config: %{"field" => "risk_factor", "cases" => "high,medium,low"}
+      )
+
+    # Column 4 (x=1020): Second logic stage
+    sort_hotspots =
+      Node.new(:sort,
+        position: {1020, 20},
+        config: %{"field" => "risk_score", "direction" => "desc"}
+      )
+
+    agg_low_risk =
+      Node.new(:aggregate,
+        position: {1020, 120},
+        config: %{"operations" => "count,avg:risk_score,max:complexity,sum:revisions"}
+      )
+
+    dedup_couplings =
+      Node.new(:remove_duplicates,
+        position: {1020, 240},
+        config: %{"field" => "entity"}
+      )
+
+    sort_stale =
+      Node.new(:sort,
+        position: {1020, 600},
+        config: %{"field" => "last_modified", "direction" => "asc"}
+      )
+
+    # Column 5 (x=1320): Third logic stage
+    limit_hotspots =
+      Node.new(:limit,
+        position: {1320, 20},
+        config: %{"count" => "20", "from" => "start"}
+      )
+
+    sort_couplings =
+      Node.new(:sort,
+        position: {1320, 240},
+        config: %{"field" => "degree", "direction" => "desc"}
+      )
+
+    limit_stale =
+      Node.new(:limit,
+        position: {1320, 600},
+        config: %{"count" => "10", "from" => "start"}
+      )
+
+    # Column 6 (x=1620): Final stage
+    limit_couplings =
+      Node.new(:limit,
+        position: {1620, 240},
+        config: %{"count" => "15", "from" => "start"}
+      )
+
+    merge_node =
+      Node.new(:merge,
+        position: {1620, 120},
+        config: %{"mode" => "append"}
+      )
+
+    Pipeline.new("Codebase Intelligence Report",
+      description:
+        "Advanced multi-stage pipeline: analyzes hotspots, couplings, knowledge silos, and code age, " <>
+          "then filters, sorts, groups, aggregates, and merges results into actionable findings"
+    )
+    |> add_nodes([
+      git,
+      hotspots,
+      couplings,
+      silos,
+      age,
+      summary_node,
+      # Logic stage 1
+      if_node,
+      filter_node,
+      group_node,
+      switch_node,
+      # Logic stage 2
+      sort_hotspots,
+      agg_low_risk,
+      dedup_couplings,
+      sort_stale,
+      # Logic stage 3
+      limit_hotspots,
+      sort_couplings,
+      limit_stale,
+      # Final
+      limit_couplings,
+      merge_node
+    ])
+    # ── Git Log → all analyzers ──
+    |> connect(git, hotspots)
+    |> connect(git, couplings)
+    |> connect(git, silos)
+    |> connect(git, age)
+    |> connect(git, summary_node)
+    # ── Hotspot path: IF → Sort → Limit → Merge.a ──
+    |> connect(hotspots, if_node)
+    |> connect_ports(if_node, "true", sort_hotspots, "items")
+    |> connect_ports(if_node, "false", agg_low_risk, "items")
+    |> connect(sort_hotspots, limit_hotspots)
+    |> connect_ports(limit_hotspots, "items", merge_node, "items_a")
+    # ── Coupling path: Filter → Dedup → Sort → Limit → Merge.b ──
+    |> connect(couplings, filter_node)
+    |> connect_ports(filter_node, "kept", dedup_couplings, "items")
+    |> connect(dedup_couplings, sort_couplings)
+    |> connect(sort_couplings, limit_couplings)
+    |> connect_ports(limit_couplings, "items", merge_node, "items_b")
+    # ── Knowledge path: Silos → Group By ──
+    |> connect(silos, group_node)
+    # ── Code age path: Switch → Sort(high risk) → Limit ──
+    |> connect(age, switch_node)
+    |> connect_ports(switch_node, "case_0", sort_stale, "items")
+    |> connect(sort_stale, limit_stale)
+  end
+
+  # ── Wiring helpers ───────────────────────────────────────────
+
+  defp add_nodes(pipeline, nodes) do
+    Enum.reduce(nodes, pipeline, &Pipeline.add_node(&2, &1))
+  end
+
+  @doc false
+  # Connect source node's first output port to target node's first input port
+  defp connect(pipeline, source, target) do
+    [out | _] = source.output_ports
+    [inp | _] = target.input_ports
+    edge = Edge.new(source.id, out.id, target.id, inp.id)
+    Pipeline.add_edge(pipeline, edge)
+  end
+
+  # Connect a specific named output port to a specific named input port
+  defp connect_ports(pipeline, source, out_name, target, in_name) do
+    out_port = Enum.find(source.output_ports, &(&1.name == out_name))
+    in_port = Enum.find(target.input_ports, &(&1.name == in_name))
+
+    if out_port && in_port do
+      edge = Edge.new(source.id, out_port.id, target.id, in_port.id)
+      Pipeline.add_edge(pipeline, edge)
+    else
+      pipeline
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/mix.exs b/apps/gitlock_workflows/mix.exs
new file mode 100644
index 0000000..7aae8db
--- /dev/null
+++ b/apps/gitlock_workflows/mix.exs
@@ -0,0 +1,36 @@
+defmodule GitlockWorkflows.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :gitlock_workflows,
+      version: "0.1.0",
+      build_path: "../../_build",
+      config_path: "../../config/config.exs",
+      deps_path: "../../deps",
+      lockfile: "../../mix.lock",
+      elixir: "~> 1.18",
+      elixirc_paths: elixirc_paths(Mix.env()),
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  def application do
+    [
+      mod: {GitlockWorkflows.Application, []},
+      extra_applications: [:logger]
+    ]
+  end
+
+  defp elixirc_paths(:test), do: ["lib", "test/support"]
+  defp elixirc_paths(_), do: ["lib"]
+
+  defp deps do
+    [
+      {:gitlock_core, in_umbrella: true},
+      {:reactor, "~> 0.15.6"},
+      {:jason, "~> 1.4"}
+    ]
+  end
+end
diff --git a/apps/gitlock_workflows/package-lock.json b/apps/gitlock_workflows/package-lock.json
new file mode 100644
index 0000000..aa50ab3
--- /dev/null
+++ b/apps/gitlock_workflows/package-lock.json
@@ -0,0 +1,6 @@
+{
+  "name": "gitlock_workflows",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/compiler_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/compiler_test.exs
new file mode 100644
index 0000000..3a5d7ea
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/compiler_test.exs
@@ -0,0 +1,178 @@
+defmodule GitlockWorkflows.CompilerTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.{Compiler, Pipeline, Node, Edge, Templates}
+  alias GitlockWorkflows.Runtime.Workflow
+
+  describe "to_workflow/1" do
+    test "converts hotspot_scan template to workflow" do
+      pipeline = Templates.build(:hotspot_scan)
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+
+      assert %Workflow{} = workflow
+      assert workflow.name == "Hotspot Quick Scan"
+      assert workflow.id == pipeline.id
+
+      # git_log + hotspot_detection + summary = 3 nodes, all have runtime types
+      assert length(workflow.nodes) == 3
+
+      types = Enum.map(workflow.nodes, & &1.type)
+      assert "gitlock.trigger.git_commits" in types
+      assert "gitlock.analysis.hotspot" in types
+      assert "gitlock.analysis.summary" in types
+    end
+
+    test "converts full_analysis template" do
+      pipeline = Templates.build(:full_analysis)
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+
+      # git_log + 5 analyzers + summary = 7 (blast_radius has no runtime impl)
+      assert length(workflow.nodes) == 7
+
+      types = MapSet.new(workflow.nodes, & &1.type)
+      assert MapSet.member?(types, "gitlock.trigger.git_commits")
+      assert MapSet.member?(types, "gitlock.analysis.hotspot")
+      assert MapSet.member?(types, "gitlock.analysis.coupling")
+      assert MapSet.member?(types, "gitlock.analysis.knowledge_silo")
+      assert MapSet.member?(types, "gitlock.analysis.code_age")
+      assert MapSet.member?(types, "gitlock.analysis.coupled_hotspot")
+      assert MapSet.member?(types, "gitlock.analysis.summary")
+    end
+
+    test "converts edges to connections with port names" do
+      pipeline = Templates.build(:hotspot_scan)
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+
+      # hotspot_scan has: git_log→hotspot, git_log→summary
+      assert length(workflow.connections) == 2
+
+      # Verify connections use port names, not port IDs
+      for conn <- workflow.connections do
+        assert is_binary(conn.from.port)
+        assert is_binary(conn.to.port)
+        # Port names should be readable, not hex IDs
+        refute String.match?(conn.from.port, ~r/^[0-9a-f]{16}$/)
+      end
+    end
+
+    test "connections reference correct port names" do
+      pipeline = Templates.build(:hotspot_scan)
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+
+      # git_log outputs "commits" → hotspot takes "commits"
+      git_node = Enum.find(workflow.nodes, &(&1.type == "gitlock.trigger.git_commits"))
+      hotspot_node = Enum.find(workflow.nodes, &(&1.type == "gitlock.analysis.hotspot"))
+
+      git_to_hotspot =
+        Enum.find(workflow.connections, fn conn ->
+          conn.from.node == git_node.id and conn.to.node == hotspot_node.id
+        end)
+
+      assert git_to_hotspot != nil
+      assert git_to_hotspot.from.port == "commits"
+      assert git_to_hotspot.to.port == "commits"
+    end
+
+    test "preserves node IDs across compilation" do
+      pipeline = Templates.build(:hotspot_scan)
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+
+      pipeline_node_ids = pipeline.nodes |> Map.keys() |> MapSet.new()
+      workflow_node_ids = MapSet.new(workflow.nodes, & &1.id)
+
+      # All workflow node IDs should be from the original pipeline
+      assert MapSet.subset?(workflow_node_ids, pipeline_node_ids)
+    end
+
+    test "skips output nodes without runtime implementations" do
+      # Build a pipeline with a csv_report output node
+      git = Node.new(:git_log)
+      hotspots = Node.new(:hotspot_detection)
+      csv = Node.new(:csv_report)
+
+      git_out = Enum.find(git.output_ports, &(&1.name == "commits"))
+      hs_in = Enum.find(hotspots.input_ports, &(&1.name == "commits"))
+      [hs_out] = hotspots.output_ports
+      [csv_in] = csv.input_ports
+
+      pipeline =
+        Pipeline.new("With Output")
+        |> Pipeline.add_node(git)
+        |> Pipeline.add_node(hotspots)
+        |> Pipeline.add_node(csv)
+        |> Pipeline.add_edge(Edge.new(git.id, git_out.id, hotspots.id, hs_in.id))
+        |> Pipeline.add_edge(Edge.new(hotspots.id, hs_out.id, csv.id, csv_in.id))
+
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+
+      # csv_report should be skipped
+      types = Enum.map(workflow.nodes, & &1.type)
+      refute "csv_report" in types
+      assert length(workflow.nodes) == 2
+
+      # Edge to csv_report should also be skipped
+      assert length(workflow.connections) == 1
+    end
+
+    test "empty pipeline compiles to empty workflow" do
+      pipeline = Pipeline.new("Empty")
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+
+      assert workflow.nodes == []
+      assert workflow.connections == []
+    end
+  end
+
+  describe "compile/1" do
+    test "produces reactor-ready workflow from template" do
+      pipeline = Templates.build(:hotspot_scan)
+      {:ok, workflow} = Compiler.compile(pipeline)
+
+      assert Workflow.reactor_ready?(workflow)
+    end
+
+    test "injects repo_path into trigger node parameters" do
+      pipeline = Templates.build(:hotspot_scan)
+      {:ok, workflow} = Compiler.to_workflow(pipeline, repo_path: "/tmp/test-repo")
+
+      trigger = Enum.find(workflow.nodes, &(&1.type == "gitlock.trigger.git_commits"))
+      assert trigger.parameters["repo_path"] == "/tmp/test-repo"
+    end
+
+    test "falls back to repo_url from config when no repo_path option" do
+      git = Node.new(:git_log, config: %{"repo_url" => "https://github.com/test/repo"})
+      hs = Node.new(:hotspot_detection)
+      git_out = Enum.find(git.output_ports, &(&1.name == "commits"))
+      hs_in = Enum.find(hs.input_ports, &(&1.name == "commits"))
+
+      pipeline =
+        Pipeline.new("Test")
+        |> Pipeline.add_node(git)
+        |> Pipeline.add_node(hs)
+        |> Pipeline.add_edge(Edge.new(git.id, git_out.id, hs.id, hs_in.id))
+
+      {:ok, workflow} = Compiler.to_workflow(pipeline)
+      trigger = Enum.find(workflow.nodes, &(&1.type == "gitlock.trigger.git_commits"))
+      assert trigger.parameters["repo_path"] == "https://github.com/test/repo"
+    end
+
+    test "empty pipeline fails reactor compilation" do
+      pipeline = Pipeline.new("Empty")
+      assert {:error, :empty_workflow} = Compiler.compile(pipeline)
+    end
+  end
+
+  describe "runtime_type/1" do
+    test "delegates to NodeCatalog.runtime_type" do
+      assert "gitlock.trigger.git_commits" = Compiler.runtime_type(:git_log)
+      assert "gitlock.analysis.hotspot" = Compiler.runtime_type(:hotspot_detection)
+      assert "gitlock.analysis.summary" = Compiler.runtime_type(:summary)
+    end
+
+    test "returns nil for nodes without runtime modules" do
+      assert nil == Compiler.runtime_type(:csv_report)
+      assert nil == Compiler.runtime_type(:blast_radius_analysis)
+      assert nil == Compiler.runtime_type(:nonexistent)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/executor/dag_flow_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/executor/dag_flow_test.exs
new file mode 100644
index 0000000..898a82b
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/executor/dag_flow_test.exs
@@ -0,0 +1,344 @@
+defmodule GitlockWorkflows.Executor.DagFlowTest do
+  @moduledoc """
+  Integration tests proving DAG-based data flow works end-to-end.
+  Registers mock runtime nodes, builds workflows, and verifies data passes through connections.
+  """
+  use ExUnit.Case
+
+  alias GitlockWorkflows.Runtime.Registry
+
+  # ── Test runtime nodes ───────────────────────────────────────
+
+  defmodule SourceNode do
+    use GitlockWorkflows.Runtime.Node
+
+    def metadata do
+      %{
+        id: "test.dag.source",
+        displayName: "DAG Source",
+        group: "trigger",
+        version: 1,
+        description: "Emits test data",
+        inputs: [],
+        outputs: [%{name: "items", type: {:list, :map}}],
+        parameters: []
+      }
+    end
+
+    def execute(_input, _params, _ctx) do
+      {:ok, %{items: [%{name: "a", score: 10}, %{name: "b", score: 20}]}}
+    end
+
+    def validate_parameters(_), do: :ok
+  end
+
+  defmodule TransformNode do
+    use GitlockWorkflows.Runtime.Node
+
+    def metadata do
+      %{
+        id: "test.dag.transform",
+        displayName: "DAG Transform",
+        group: "analysis",
+        version: 1,
+        description: "Doubles scores",
+        inputs: [%{name: "items", type: {:list, :map}, required: true}],
+        outputs: [%{name: "results", type: {:list, :map}}],
+        parameters: []
+      }
+    end
+
+    def execute(input_data, _params, _ctx) do
+      items = input_data[:items] || []
+      {:ok, %{results: Enum.map(items, &Map.update!(&1, :score, fn s -> s * 2 end))}}
+    end
+
+    def validate_parameters(_), do: :ok
+  end
+
+  defmodule SinkNode do
+    use GitlockWorkflows.Runtime.Node
+
+    def metadata do
+      %{
+        id: "test.dag.sink",
+        displayName: "DAG Sink",
+        group: "analysis",
+        version: 1,
+        description: "Sums scores",
+        inputs: [%{name: "results", type: {:list, :map}, required: true}],
+        outputs: [%{name: "summary", type: :map}],
+        parameters: []
+      }
+    end
+
+    def execute(input_data, _params, _ctx) do
+      results = input_data[:results] || []
+      total = Enum.reduce(results, 0, fn item, acc -> acc + item.score end)
+      {:ok, %{summary: %{count: length(results), total_score: total}}}
+    end
+
+    def validate_parameters(_), do: :ok
+  end
+
+  defmodule CountingSource do
+    use GitlockWorkflows.Runtime.Node
+
+    def metadata do
+      %{
+        id: "test.dag.counting_source",
+        displayName: "Counting Source",
+        group: "trigger",
+        version: 1,
+        description: "Counts executions",
+        inputs: [],
+        outputs: [%{name: "items", type: {:list, :map}}],
+        parameters: []
+      }
+    end
+
+    def execute(_input, _params, _ctx) do
+      Agent.update(:source_exec_count, &(&1 + 1))
+      {:ok, %{items: [%{name: "x", score: 5}]}}
+    end
+
+    def validate_parameters(_), do: :ok
+  end
+
+  # ── Setup ────────────────────────────────────────────────────
+
+  setup do
+    Registry.register_node(SourceNode)
+    Registry.register_node(TransformNode)
+    Registry.register_node(SinkNode)
+    :ok
+  end
+
+  # ── Tests ────────────────────────────────────────────────────
+
+  describe "DAG data flow" do
+    test "linear chain: source → transform → sink" do
+      workflow =
+        build_workflow(
+          [
+            node("src", "test.dag.source"),
+            node("xform", "test.dag.transform"),
+            node("sink", "test.dag.sink")
+          ],
+          [
+            conn("src", "items", "xform", "items"),
+            conn("xform", "results", "sink", "results")
+          ]
+        )
+
+      results = run_dag(workflow)
+
+      assert {:ok, src} = results["src"]
+      assert length(src.data.items) == 2
+
+      assert {:ok, xform} = results["xform"]
+      assert Enum.map(xform.data.results, & &1.score) == [20, 40]
+
+      assert {:ok, sink} = results["sink"]
+      assert sink.data.summary == %{count: 2, total_score: 60}
+    end
+
+    test "fan-out: source feeds two transforms independently" do
+      workflow =
+        build_workflow(
+          [
+            node("src", "test.dag.source"),
+            node("a", "test.dag.transform"),
+            node("b", "test.dag.transform")
+          ],
+          [
+            conn("src", "items", "a", "items"),
+            conn("src", "items", "b", "items")
+          ]
+        )
+
+      results = run_dag(workflow)
+
+      assert {:ok, ra} = results["a"]
+      assert {:ok, rb} = results["b"]
+      assert Enum.map(ra.data.results, & &1.score) == [20, 40]
+      assert Enum.map(rb.data.results, & &1.score) == [20, 40]
+    end
+
+    test "source executes exactly once despite multiple downstream consumers" do
+      Registry.register_node(CountingSource)
+      Agent.start_link(fn -> 0 end, name: :source_exec_count)
+
+      workflow =
+        build_workflow(
+          [
+            node("src", "test.dag.counting_source"),
+            node("a", "test.dag.transform"),
+            node("b", "test.dag.transform"),
+            node("c", "test.dag.transform")
+          ],
+          [
+            conn("src", "items", "a", "items"),
+            conn("src", "items", "b", "items"),
+            conn("src", "items", "c", "items")
+          ]
+        )
+
+      results = run_dag(workflow)
+
+      assert map_size(results) == 4
+      assert Agent.get(:source_exec_count, & &1) == 1
+
+      Agent.stop(:source_exec_count)
+    end
+
+    test "progress messages sent in topological order" do
+      workflow =
+        build_workflow(
+          [
+            node("src", "test.dag.source"),
+            node("xform", "test.dag.transform")
+          ],
+          [
+            conn("src", "items", "xform", "items")
+          ]
+        )
+
+      me = self()
+
+      Task.start_link(fn ->
+        results = run_dag(workflow, me)
+        send(me, {:pipeline_complete, results})
+      end)
+
+      messages = collect_messages(10)
+
+      events =
+        Enum.map(messages, fn
+          {:pipeline_progress, id, :running} -> {:running, id}
+          {:pipeline_progress, id, {:done, _}} -> {:done, id}
+          {:pipeline_complete, _} -> :complete
+        end)
+
+      # src finishes before xform starts
+      src_done = Enum.find_index(events, &(&1 == {:done, "src"}))
+      xform_run = Enum.find_index(events, &(&1 == {:running, "xform"}))
+      assert src_done < xform_run
+    end
+  end
+
+  # ── Workflow builder helpers ─────────────────────────────────
+
+  defp node(id, type),
+    do: %{id: id, type: type, position: [0, 0], parameters: %{}, disabled: false}
+
+  defp conn(from_node, from_port, to_node, to_port) do
+    %{from: %{node: from_node, port: from_port}, to: %{node: to_node, port: to_port}}
+  end
+
+  defp build_workflow(nodes, connections) do
+    %GitlockWorkflows.Runtime.Workflow{
+      id: "test-#{:erlang.unique_integer([:positive])}",
+      name: "Test Workflow",
+      nodes: nodes,
+      connections: connections,
+      settings: %{},
+      version: 1
+    }
+  end
+
+  # ── DAG execution (mirrors Executor internals) ───────────────
+
+  defp run_dag(workflow, caller \\ nil) do
+    node_index = Map.new(workflow.nodes, &{&1.id, &1})
+    sorted = topo_sort(workflow)
+
+    sorted
+    |> Enum.reduce({%{}, %{}}, fn node_id, {outputs, results} ->
+      node_def = Map.fetch!(node_index, node_id)
+      notify(caller, {:pipeline_progress, node_id, :running})
+
+      input_data = gather_inputs(node_id, workflow.connections, outputs)
+
+      case run_node(node_def, input_data) do
+        {:ok, output_data} ->
+          notify(caller, {:pipeline_progress, node_id, {:done, output_data}})
+
+          result =
+            {:ok,
+             %{node_id: node_id, type: node_def.type, label: node_def.type, data: output_data}}
+
+          {Map.put(outputs, node_id, output_data), Map.put(results, node_id, result)}
+
+        {:error, _} = err ->
+          notify(caller, {:pipeline_progress, node_id, err})
+          {outputs, Map.put(results, node_id, err)}
+      end
+    end)
+    |> elem(1)
+  end
+
+  defp run_node(node_def, input_data) do
+    {:ok, mod} = Registry.get_node(node_def.type)
+    mod.execute(input_data, node_def.parameters, %{})
+  end
+
+  defp gather_inputs(node_id, connections, outputs) do
+    connections
+    |> Enum.filter(&(&1.to.node == node_id))
+    |> Enum.reduce(%{}, fn conn, acc ->
+      case Map.get(outputs, conn.from.node) do
+        upstream when is_map(upstream) ->
+          key = String.to_atom(conn.from.port)
+
+          case Map.get(upstream, key) do
+            nil -> acc
+            val -> Map.put(acc, String.to_atom(conn.to.port), val)
+          end
+
+        _ ->
+          acc
+      end
+    end)
+  end
+
+  defp topo_sort(workflow) do
+    ids = MapSet.new(workflow.nodes, & &1.id)
+    deg = Map.new(ids, &{&1, 0})
+
+    {adj, deg} =
+      Enum.reduce(workflow.connections, {%{}, deg}, fn c, {a, d} ->
+        {Map.update(a, c.from.node, [c.to.node], &[c.to.node | &1]),
+         Map.update(d, c.to.node, 1, &(&1 + 1))}
+      end)
+
+    queue = for {id, 0} <- deg, do: id
+    do_topo(queue, adj, deg, [])
+  end
+
+  defp do_topo([], _, _, r), do: Enum.reverse(r)
+
+  defp do_topo([h | t], adj, deg, r) do
+    {q, d} =
+      Enum.reduce(Map.get(adj, h, []), {[], deg}, fn n, {q, d} ->
+        d = Map.update!(d, n, &(&1 - 1))
+        if d[n] == 0, do: {[n | q], d}, else: {q, d}
+      end)
+
+    do_topo(t ++ Enum.reverse(q), adj, d, [h | r])
+  end
+
+  defp notify(nil, _), do: :ok
+  defp notify(pid, msg), do: send(pid, msg)
+
+  defp collect_messages(max, acc \\ [])
+  defp collect_messages(0, acc), do: Enum.reverse(acc)
+
+  defp collect_messages(n, acc) do
+    receive do
+      msg -> collect_messages(n - 1, [msg | acc])
+    after
+      2000 -> Enum.reverse(acc)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/executor_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/executor_test.exs
new file mode 100644
index 0000000..4e6e283
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/executor_test.exs
@@ -0,0 +1,75 @@
+defmodule GitlockWorkflows.ExecutorTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.{Executor, Pipeline, Node, Templates}
+
+  describe "executable_nodes/1" do
+    test "returns nodes with runtime implementations" do
+      pipeline = Templates.build(:hotspot_scan)
+      executable = Executor.executable_nodes(pipeline)
+
+      types = Enum.map(executable, & &1.type)
+
+      # DAG execution includes the trigger node
+      assert :git_log in types
+      assert :hotspot_detection in types
+      assert :summary in types
+    end
+
+    test "full analysis has all compilable nodes" do
+      pipeline = Templates.build(:full_analysis)
+      executable = Executor.executable_nodes(pipeline)
+
+      types = Enum.map(executable, & &1.type) |> MapSet.new()
+
+      assert MapSet.member?(types, :git_log)
+      assert MapSet.member?(types, :hotspot_detection)
+      assert MapSet.member?(types, :coupling_detection)
+      assert MapSet.member?(types, :knowledge_silo_detection)
+      assert MapSet.member?(types, :code_age_analysis)
+      assert MapSet.member?(types, :coupled_hotspot_analysis)
+      assert MapSet.member?(types, :summary)
+
+      # blast_radius has no runtime impl
+      refute MapSet.member?(types, :blast_radius_analysis)
+    end
+
+    test "empty pipeline returns empty list" do
+      pipeline = Pipeline.new("Empty")
+      assert [] = Executor.executable_nodes(pipeline)
+    end
+
+    test "excludes output nodes without runtime implementations" do
+      git = Node.new(:git_log)
+      csv = Node.new(:csv_report)
+
+      pipeline =
+        Pipeline.new("Test")
+        |> Pipeline.add_node(git)
+        |> Pipeline.add_node(csv)
+
+      executable = Executor.executable_nodes(pipeline)
+      types = Enum.map(executable, & &1.type)
+
+      assert :git_log in types
+      refute :csv_report in types
+    end
+  end
+
+  describe "templates produce valid pipelines" do
+    test "hotspot_scan validates" do
+      pipeline = Templates.build(:hotspot_scan)
+      assert :ok = Pipeline.validate(pipeline)
+    end
+
+    test "full_analysis validates" do
+      pipeline = Templates.build(:full_analysis)
+      assert :ok = Pipeline.validate(pipeline)
+    end
+
+    test "knowledge_risk validates" do
+      pipeline = Templates.build(:knowledge_risk)
+      assert :ok = Pipeline.validate(pipeline)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/node_catalog_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/node_catalog_test.exs
new file mode 100644
index 0000000..01f4724
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/node_catalog_test.exs
@@ -0,0 +1,191 @@
+defmodule GitlockWorkflows.NodeCatalogTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.NodeCatalog
+
+  describe "list_types/0" do
+    test "returns all available node types" do
+      types = NodeCatalog.list_types()
+
+      assert is_list(types)
+      assert length(types) > 0
+
+      type_ids = Enum.map(types, & &1.type_id)
+      assert :git_log in type_ids
+      assert :hotspot_detection in type_ids
+      assert :csv_report in type_ids
+    end
+
+    test "every type has a runtime_module field" do
+      for type_def <- NodeCatalog.list_types() do
+        assert Map.has_key?(type_def, :runtime_module),
+               "Type #{type_def.type_id} missing runtime_module field"
+      end
+    end
+  end
+
+  describe "get_type/1" do
+    test "returns type definition for known type" do
+      {:ok, type_def} = NodeCatalog.get_type(:git_log)
+
+      assert type_def.type_id == :git_log
+      assert type_def.category == :source
+      assert type_def.label == "Git Log"
+      assert type_def.input_ports == []
+      assert length(type_def.output_ports) == 1
+    end
+
+    test "returns error for unknown type" do
+      assert {:error, :unknown_node_type} = NodeCatalog.get_type(:does_not_exist)
+    end
+  end
+
+  describe "runtime_module/1" do
+    test "returns module for nodes with runtime implementations" do
+      assert GitlockWorkflows.Runtime.Nodes.Triggers.GitCommits =
+               NodeCatalog.runtime_module(:git_log)
+
+      assert GitlockWorkflows.Runtime.Nodes.Analysis.Hotspot =
+               NodeCatalog.runtime_module(:hotspot_detection)
+
+      assert GitlockWorkflows.Runtime.Nodes.Analysis.Coupling =
+               NodeCatalog.runtime_module(:coupling_detection)
+
+      assert GitlockWorkflows.Runtime.Nodes.Analysis.KnowledgeSilo =
+               NodeCatalog.runtime_module(:knowledge_silo_detection)
+
+      assert GitlockWorkflows.Runtime.Nodes.Analysis.CodeAge =
+               NodeCatalog.runtime_module(:code_age_analysis)
+
+      assert GitlockWorkflows.Runtime.Nodes.Analysis.CoupledHotspot =
+               NodeCatalog.runtime_module(:coupled_hotspot_analysis)
+
+      assert GitlockWorkflows.Runtime.Nodes.Analysis.Summary =
+               NodeCatalog.runtime_module(:summary)
+    end
+
+    test "returns nil for output nodes" do
+      assert nil == NodeCatalog.runtime_module(:csv_report)
+      assert nil == NodeCatalog.runtime_module(:json_report)
+    end
+
+    test "returns nil for nodes without implementations" do
+      assert nil == NodeCatalog.runtime_module(:blast_radius_analysis)
+    end
+
+    test "returns nil for unknown nodes" do
+      assert nil == NodeCatalog.runtime_module(:nonexistent)
+    end
+  end
+
+  describe "runtime_type/1" do
+    test "returns registry ID string from module metadata" do
+      assert "gitlock.trigger.git_commits" = NodeCatalog.runtime_type(:git_log)
+      assert "gitlock.analysis.hotspot" = NodeCatalog.runtime_type(:hotspot_detection)
+      assert "gitlock.analysis.summary" = NodeCatalog.runtime_type(:summary)
+    end
+
+    test "returns nil for nodes without runtime modules" do
+      assert nil == NodeCatalog.runtime_type(:csv_report)
+      assert nil == NodeCatalog.runtime_type(:blast_radius_analysis)
+      assert nil == NodeCatalog.runtime_type(:nonexistent)
+    end
+  end
+
+  describe "runtime_modules/0" do
+    test "returns all modules from the catalog" do
+      modules = NodeCatalog.runtime_modules()
+
+      assert is_list(modules)
+      assert length(modules) > 0
+      assert GitlockWorkflows.Runtime.Nodes.Triggers.GitCommits in modules
+      assert GitlockWorkflows.Runtime.Nodes.Analysis.Hotspot in modules
+    end
+
+    test "does not include nil" do
+      modules = NodeCatalog.runtime_modules()
+      refute nil in modules
+    end
+  end
+
+  describe "executable_types/0" do
+    test "returns only types with runtime modules" do
+      executable = NodeCatalog.executable_types()
+
+      assert length(executable) > 0
+
+      for type_def <- executable do
+        assert type_def.runtime_module != nil,
+               "Executable type #{type_def.type_id} should have a runtime_module"
+      end
+    end
+
+    test "does not include source or output nodes without runtime" do
+      executable_ids =
+        NodeCatalog.executable_types()
+        |> Enum.map(& &1.type_id)
+        |> MapSet.new()
+
+      refute MapSet.member?(executable_ids, :csv_report)
+      refute MapSet.member?(executable_ids, :json_report)
+      refute MapSet.member?(executable_ids, :blast_radius_analysis)
+    end
+  end
+
+  describe "categories" do
+    test "source nodes have no input ports" do
+      sources = NodeCatalog.by_category(:source)
+      assert length(sources) > 0
+
+      for type_def <- sources do
+        assert type_def.input_ports == [],
+               "Source node #{type_def.type_id} should have no input ports"
+      end
+    end
+
+    test "output nodes have no output ports" do
+      outputs = NodeCatalog.by_category(:output)
+      assert length(outputs) > 0
+
+      for type_def <- outputs do
+        assert type_def.output_ports == [],
+               "Output node #{type_def.type_id} should have no output ports"
+      end
+    end
+
+    test "analysis nodes have both input and output ports" do
+      analyzers = NodeCatalog.by_category(:analyze)
+      assert length(analyzers) > 0
+
+      for type_def <- analyzers do
+        assert length(type_def.input_ports) > 0,
+               "Analysis node #{type_def.type_id} should have input ports"
+
+        assert length(type_def.output_ports) > 0,
+               "Analysis node #{type_def.type_id} should have output ports"
+      end
+    end
+
+    test "no output nodes have runtime modules" do
+      outputs = NodeCatalog.by_category(:output)
+
+      for type_def <- outputs do
+        assert type_def.runtime_module == nil,
+               "Output node #{type_def.type_id} should not have a runtime_module"
+      end
+    end
+  end
+
+  describe "by_category/1" do
+    test "filters by category" do
+      sources = NodeCatalog.by_category(:source)
+
+      assert length(sources) > 0
+      assert Enum.all?(sources, &(&1.category == :source))
+    end
+
+    test "returns empty list for unknown category" do
+      assert [] = NodeCatalog.by_category(:nonexistent)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/pipeline_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/pipeline_test.exs
new file mode 100644
index 0000000..4516ada
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/pipeline_test.exs
@@ -0,0 +1,364 @@
+defmodule GitlockWorkflows.PipelineTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.{Pipeline, Node, Edge}
+
+  # Helper to find a port by name in a list of ports
+  defp find_port(ports, name), do: Enum.find(ports, &(&1.name == name))
+
+  # ─── Node Creation ──────────────────────────────────────────────
+
+  describe "Node.new/2 from catalog type" do
+    test "creates a source node with output ports" do
+      node = Node.new(:git_log)
+
+      assert node.type == :git_log
+      assert node.label == "Git Log"
+      assert node.input_ports == []
+      assert length(node.output_ports) == 1
+
+      [port] = node.output_ports
+      assert port.data_type == :commits
+      assert port.name == "commits"
+    end
+
+    test "creates an analysis node with input and output ports" do
+      node = Node.new(:hotspot_detection)
+
+      assert node.type == :hotspot_detection
+      assert length(node.input_ports) == 2
+      assert length(node.output_ports) == 1
+
+      commits_input = find_port(node.input_ports, "commits")
+      assert commits_input.data_type == :commits
+
+      complexity_input = find_port(node.input_ports, "complexity_map")
+      assert complexity_input.data_type == :map
+      assert complexity_input.optional == true
+
+      [output] = node.output_ports
+      assert output.data_type == :hotspots
+    end
+
+    test "creates an output node with input ports only" do
+      node = Node.new(:csv_report)
+
+      assert node.type == :csv_report
+      assert length(node.input_ports) == 1
+      assert node.output_ports == []
+
+      [input] = node.input_ports
+      assert input.data_type == :analysis_result
+    end
+
+    test "generates unique id per node" do
+      node_a = Node.new(:git_log)
+      node_b = Node.new(:git_log)
+
+      assert node_a.id != node_b.id
+    end
+
+    test "accepts position option" do
+      node = Node.new(:git_log, position: {100, 200})
+
+      assert node.position == {100, 200}
+    end
+
+    test "defaults position to origin" do
+      node = Node.new(:git_log)
+
+      assert node.position == {0, 0}
+    end
+
+    test "accepts config option" do
+      node = Node.new(:git_log, config: %{depth: 500, branch: "develop"})
+
+      assert node.config == %{depth: 500, branch: "develop"}
+    end
+
+    test "rejects unknown node type" do
+      assert {:error, :unknown_node_type} = Node.new(:nonexistent_type)
+    end
+  end
+
+  # ─── Edge Creation ──────────────────────────────────────────────
+
+  describe "Edge.new/4" do
+    test "creates an edge between two ports" do
+      source = Node.new(:git_log)
+      target = Node.new(:hotspot_detection)
+
+      source_port = find_port(source.output_ports, "commits")
+      target_port = find_port(target.input_ports, "commits")
+
+      edge = Edge.new(source.id, source_port.id, target.id, target_port.id)
+
+      assert edge.source_node_id == source.id
+      assert edge.source_port_id == source_port.id
+      assert edge.target_node_id == target.id
+      assert edge.target_port_id == target_port.id
+    end
+
+    test "generates unique id" do
+      edge_a = Edge.new("n1", "p1", "n2", "p2")
+      edge_b = Edge.new("n1", "p1", "n2", "p2")
+
+      assert edge_a.id != edge_b.id
+    end
+  end
+
+  # ─── Pipeline Construction ──────────────────────────────────────
+
+  describe "Pipeline.new/2" do
+    test "creates empty pipeline with name" do
+      pipeline = Pipeline.new("Hotspot Analysis")
+
+      assert pipeline.name == "Hotspot Analysis"
+      assert pipeline.nodes == %{}
+      assert pipeline.edges == %{}
+      assert is_binary(pipeline.id)
+    end
+  end
+
+  describe "Pipeline.add_node/2" do
+    test "adds a node to the pipeline" do
+      node = Node.new(:git_log)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(node)
+
+      assert Map.has_key?(pipeline.nodes, node.id)
+      assert pipeline.nodes[node.id] == node
+    end
+
+    test "rejects duplicate node id" do
+      node = Node.new(:git_log)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(node)
+
+      assert {:error, :duplicate_node} = Pipeline.add_node(pipeline, node)
+    end
+  end
+
+  describe "Pipeline.add_edge/2" do
+    setup do
+      source = Node.new(:git_log)
+      target = Node.new(:hotspot_detection)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(source)
+        |> Pipeline.add_node(target)
+
+      %{pipeline: pipeline, source: source, target: target}
+    end
+
+    test "connects compatible ports", %{pipeline: pipeline, source: source, target: target} do
+      source_port = find_port(source.output_ports, "commits")
+      target_port = find_port(target.input_ports, "commits")
+
+      edge = Edge.new(source.id, source_port.id, target.id, target_port.id)
+      pipeline = Pipeline.add_edge(pipeline, edge)
+
+      assert Map.has_key?(pipeline.edges, edge.id)
+    end
+
+    test "rejects edge to non-existent source node", %{pipeline: pipeline, target: target} do
+      target_port = find_port(target.input_ports, "commits")
+      edge = Edge.new("ghost", "p1", target.id, target_port.id)
+
+      assert {:error, :source_node_not_found} = Pipeline.add_edge(pipeline, edge)
+    end
+
+    test "rejects edge to non-existent target node", %{pipeline: pipeline, source: source} do
+      source_port = find_port(source.output_ports, "commits")
+      edge = Edge.new(source.id, source_port.id, "ghost", "p1")
+
+      assert {:error, :target_node_not_found} = Pipeline.add_edge(pipeline, edge)
+    end
+
+    test "rejects edge with non-existent source port", %{
+      pipeline: pipeline,
+      source: source,
+      target: target
+    } do
+      target_port = find_port(target.input_ports, "commits")
+      edge = Edge.new(source.id, "bad_port", target.id, target_port.id)
+
+      assert {:error, :source_port_not_found} = Pipeline.add_edge(pipeline, edge)
+    end
+
+    test "rejects edge with non-existent target port", %{
+      pipeline: pipeline,
+      source: source,
+      target: target
+    } do
+      source_port = find_port(source.output_ports, "commits")
+      edge = Edge.new(source.id, source_port.id, target.id, "bad_port")
+
+      assert {:error, :target_port_not_found} = Pipeline.add_edge(pipeline, edge)
+    end
+
+    test "rejects edge between incompatible port types" do
+      # hotspot output is :hotspots, coupling input expects :commits
+      hotspot_node = Node.new(:hotspot_detection)
+      coupling_node = Node.new(:coupling_detection)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(hotspot_node)
+        |> Pipeline.add_node(coupling_node)
+
+      [source_port] = hotspot_node.output_ports
+      target_port = find_port(coupling_node.input_ports, "commits")
+
+      edge = Edge.new(hotspot_node.id, source_port.id, coupling_node.id, target_port.id)
+
+      assert {:error, :incompatible_port_types} = Pipeline.add_edge(pipeline, edge)
+    end
+  end
+
+  describe "Pipeline.remove_node/2" do
+    test "removes node and its connected edges" do
+      source = Node.new(:git_log)
+      middle = Node.new(:hotspot_detection)
+      output = Node.new(:csv_report)
+
+      src_port = find_port(source.output_ports, "commits")
+      mid_in = find_port(middle.input_ports, "commits")
+      [mid_out] = middle.output_ports
+      [out_port] = output.input_ports
+
+      edge1 = Edge.new(source.id, src_port.id, middle.id, mid_in.id)
+      edge2 = Edge.new(middle.id, mid_out.id, output.id, out_port.id)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(source)
+        |> Pipeline.add_node(middle)
+        |> Pipeline.add_node(output)
+        |> Pipeline.add_edge(edge1)
+        |> Pipeline.add_edge(edge2)
+
+      # Sanity: 3 nodes, 2 edges
+      assert map_size(pipeline.nodes) == 3
+      assert map_size(pipeline.edges) == 2
+
+      # Remove middle node — both edges should go
+      pipeline = Pipeline.remove_node(pipeline, middle.id)
+
+      assert map_size(pipeline.nodes) == 2
+      assert map_size(pipeline.edges) == 0
+      refute Map.has_key?(pipeline.nodes, middle.id)
+    end
+
+    test "returns unchanged pipeline for non-existent node" do
+      pipeline = Pipeline.new("test")
+
+      assert pipeline == Pipeline.remove_node(pipeline, "ghost")
+    end
+  end
+
+  describe "Pipeline.remove_edge/2" do
+    test "removes an edge by id" do
+      source = Node.new(:git_log)
+      target = Node.new(:hotspot_detection)
+      src_port = find_port(source.output_ports, "commits")
+      tgt_port = find_port(target.input_ports, "commits")
+      edge = Edge.new(source.id, src_port.id, target.id, tgt_port.id)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(source)
+        |> Pipeline.add_node(target)
+        |> Pipeline.add_edge(edge)
+
+      pipeline = Pipeline.remove_edge(pipeline, edge.id)
+
+      assert map_size(pipeline.edges) == 0
+    end
+  end
+
+  # ─── Pipeline Validation ────────────────────────────────────────
+
+  describe "Pipeline.validate/1" do
+    test "valid three-node pipeline" do
+      source = Node.new(:git_log)
+      analysis = Node.new(:hotspot_detection)
+      output = Node.new(:csv_report)
+
+      src_port = find_port(source.output_ports, "commits")
+      ana_in = find_port(analysis.input_ports, "commits")
+      [ana_out] = analysis.output_ports
+      [out_port] = output.input_ports
+
+      pipeline =
+        Pipeline.new("Full Pipeline")
+        |> Pipeline.add_node(source)
+        |> Pipeline.add_node(analysis)
+        |> Pipeline.add_node(output)
+        |> Pipeline.add_edge(Edge.new(source.id, src_port.id, analysis.id, ana_in.id))
+        |> Pipeline.add_edge(Edge.new(analysis.id, ana_out.id, output.id, out_port.id))
+
+      assert :ok = Pipeline.validate(pipeline)
+    end
+
+    test "detects unconnected required input ports" do
+      # Analysis node with no source feeding it
+      analysis = Node.new(:hotspot_detection)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(analysis)
+
+      assert {:error, errors} = Pipeline.validate(pipeline)
+      assert :unconnected_inputs in Keyword.keys(errors)
+    end
+
+    test "empty pipeline is valid" do
+      pipeline = Pipeline.new("empty")
+
+      assert :ok = Pipeline.validate(pipeline)
+    end
+
+    test "source-only pipeline is valid (no required inputs)" do
+      source = Node.new(:git_log)
+
+      pipeline =
+        Pipeline.new("test")
+        |> Pipeline.add_node(source)
+
+      assert :ok = Pipeline.validate(pipeline)
+    end
+  end
+
+  # ─── Full Scenario ─────────────────────────────────────────────
+
+  describe "realistic pipeline construction" do
+    test "builds GitLog → HotspotDetection → CSVReport" do
+      git_log = Node.new(:git_log, config: %{depth: 1000}, position: {0, 100})
+      hotspots = Node.new(:hotspot_detection, position: {300, 100})
+      report = Node.new(:csv_report, position: {600, 100})
+
+      git_out = find_port(git_log.output_ports, "commits")
+      hs_in = find_port(hotspots.input_ports, "commits")
+      [hs_out] = hotspots.output_ports
+      [rpt_in] = report.input_ports
+
+      pipeline =
+        Pipeline.new("Hotspot Analysis")
+        |> Pipeline.add_node(git_log)
+        |> Pipeline.add_node(hotspots)
+        |> Pipeline.add_node(report)
+        |> Pipeline.add_edge(Edge.new(git_log.id, git_out.id, hotspots.id, hs_in.id))
+        |> Pipeline.add_edge(Edge.new(hotspots.id, hs_out.id, report.id, rpt_in.id))
+
+      assert :ok = Pipeline.validate(pipeline)
+      assert map_size(pipeline.nodes) == 3
+      assert map_size(pipeline.edges) == 2
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/runtime/context_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/runtime/context_test.exs
new file mode 100644
index 0000000..fbe5046
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/runtime/context_test.exs
@@ -0,0 +1,350 @@
+defmodule GitlockWorkflows.Runtime.ContextTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.Runtime.Context
+
+  describe "new/3" do
+    test "creates a new context with required fields" do
+      execution_id = "exec_123"
+      workflow_id = "workflow_456"
+
+      context = Context.new(execution_id, workflow_id)
+
+      assert context.execution_id == execution_id
+      assert context.workflow_id == workflow_id
+      assert is_nil(context.workflow_name)
+      assert context.variables == %{}
+      assert context.credentials == %{}
+      assert is_binary(context.temp_storage)
+      assert is_nil(context.workspace_path)
+      assert %DateTime{} = context.start_time
+      assert context.node_executions == %{}
+      assert context.tags == %{}
+      assert context.options == %{}
+    end
+
+    test "creates context with optional parameters" do
+      context =
+        Context.new("exec_123", "workflow_456",
+          workflow_name: "Test Workflow",
+          workspace_path: "/tmp/workspace",
+          credentials: %{"github_token" => "secret"},
+          tags: %{environment: "test"},
+          options: %{timeout: 5000}
+        )
+
+      assert context.workflow_name == "Test Workflow"
+      assert context.workspace_path == "/tmp/workspace"
+      assert context.credentials == %{"github_token" => "secret"}
+      assert context.tags == %{environment: "test"}
+      assert context.options == %{timeout: 5000}
+    end
+
+    test "creates temporary storage directory" do
+      context = Context.new("exec_123", "workflow_456")
+
+      assert File.dir?(context.temp_storage)
+      assert String.contains?(context.temp_storage, "exec_123")
+
+      # Cleanup
+      File.rm_rf!(context.temp_storage)
+    end
+  end
+
+  describe "get_execution_id/1 and get_workflow_id/1" do
+    setup do
+      context = Context.new("exec_123", "workflow_456")
+      {:ok, context: context}
+    end
+
+    test "returns execution id", %{context: context} do
+      assert Context.get_execution_id(context) == "exec_123"
+    end
+
+    test "returns workflow id", %{context: context} do
+      assert Context.get_workflow_id(context) == "workflow_456"
+    end
+  end
+
+  describe "variable management" do
+    setup do
+      context = Context.new("exec_123", "workflow_456")
+      {:ok, context: context}
+    end
+
+    test "get_variable returns nil for non-existent variable", %{context: context} do
+      assert Context.get_variable(context, "missing") == nil
+    end
+
+    test "set and get variable", %{context: context} do
+      context = Context.set_variable(context, "test_key", "test_value")
+      assert Context.get_variable(context, "test_key") == "test_value"
+    end
+
+    test "set variable with complex data", %{context: context} do
+      data = %{
+        files: ["file1.ex", "file2.ex"],
+        metrics: %{count: 10, complexity: 5.5}
+      }
+
+      context = Context.set_variable(context, "analysis_result", data)
+      assert Context.get_variable(context, "analysis_result") == data
+    end
+
+    test "get_variables returns requested variables", %{context: context} do
+      context =
+        context
+        |> Context.set_variable("var1", "value1")
+        |> Context.set_variable("var2", "value2")
+        |> Context.set_variable("var3", "value3")
+
+      result = Context.get_variables(context, ["var1", "var3"])
+      assert result == %{"var1" => "value1", "var3" => "value3"}
+    end
+
+    test "get_variables ignores missing keys", %{context: context} do
+      context = Context.set_variable(context, "exists", "value")
+
+      result = Context.get_variables(context, ["exists", "missing"])
+      assert result == %{"exists" => "value"}
+    end
+
+    test "list_variables returns all variables", %{context: context} do
+      context =
+        context
+        |> Context.set_variable("a", 1)
+        |> Context.set_variable("b", 2)
+        |> Context.set_variable("c", 3)
+
+      vars = Context.list_variables(context)
+      assert vars == %{"a" => 1, "b" => 2, "c" => 3}
+    end
+  end
+
+  describe "logging" do
+    setup do
+      context = Context.new("exec_123", "workflow_456")
+      {:ok, context: context}
+    end
+
+    test "logs with proper metadata", %{context: context} do
+      # This test just ensures the function doesn't crash
+      # In a real test, you might capture logs or use a mock logger
+      assert :ok = Context.log(context, :info, "Test message")
+      assert :ok = Context.log(context, :debug, "Debug message")
+      assert :ok = Context.log(context, :warning, "Warning message")
+      assert :ok = Context.log(context, :error, "Error message")
+    end
+
+    test "logs with additional metadata", %{context: context} do
+      metadata = %{user_id: "user_123", action: "analyze"}
+      assert :ok = Context.log(context, :info, "Custom metadata", metadata)
+    end
+  end
+
+  describe "workspace and storage" do
+    setup do
+      {:ok, workspace_path} = Briefly.create(directory: true)
+
+      context_with_workspace =
+        Context.new("exec_123", "workflow_456", workspace_path: workspace_path)
+
+      context_without_workspace = Context.new("exec_456", "workflow_789")
+
+      {:ok,
+       with_workspace: context_with_workspace,
+       without_workspace: context_without_workspace,
+       workspace_path: workspace_path}
+    end
+
+    test "get_workspace_path returns path when available", %{
+      with_workspace: context,
+      workspace_path: path
+    } do
+      assert {:ok, ^path} = Context.get_workspace_path(context)
+    end
+
+    test "get_workspace_path returns error when not available", %{without_workspace: context} do
+      assert {:error, :no_workspace} = Context.get_workspace_path(context)
+    end
+
+    test "get_temp_storage returns path", %{with_workspace: context} do
+      temp_path = Context.get_temp_storage(context)
+      assert is_binary(temp_path)
+      assert File.dir?(temp_path)
+    end
+  end
+
+  describe "credentials" do
+    setup do
+      context =
+        Context.new("exec_123", "workflow_456",
+          credentials: %{
+            "github_token" => "ghp_secret123",
+            "api_key" => "key_456"
+          }
+        )
+
+      {:ok, context: context}
+    end
+
+    test "get_credential returns value when exists", %{context: context} do
+      assert Context.get_credential(context, "github_token") == "ghp_secret123"
+      assert Context.get_credential(context, "api_key") == "key_456"
+    end
+
+    test "get_credential returns nil when not exists", %{context: context} do
+      assert Context.get_credential(context, "missing_key") == nil
+    end
+
+    test "has_credential? checks existence", %{context: context} do
+      assert Context.has_credential?(context, "github_token") == true
+      assert Context.has_credential?(context, "missing_key") == false
+    end
+  end
+
+  describe "execution tracking" do
+    setup do
+      context = Context.new("exec_123", "workflow_456")
+      {:ok, context: context}
+    end
+
+    test "get_execution_duration returns milliseconds", %{context: context} do
+      # Sleep a bit to ensure some time passes
+      :timer.sleep(10)
+
+      duration = Context.get_execution_duration(context)
+      assert is_integer(duration)
+      assert duration >= 10
+    end
+
+    test "record_node_start tracks node execution", %{context: context} do
+      context = Context.record_node_start(context, "node_1")
+
+      node_exec = Context.get_node_execution(context, "node_1")
+      assert node_exec.node_id == "node_1"
+      assert node_exec.status == :running
+      assert is_nil(node_exec.completed_at)
+      assert %DateTime{} = node_exec.started_at
+    end
+
+    test "record_node_completion updates existing node", %{context: context} do
+      context =
+        context
+        |> Context.record_node_start("node_1")
+        |> Context.record_node_completion("node_1", :ok)
+
+      node_exec = Context.get_node_execution(context, "node_1")
+      assert node_exec.status == :completed
+      assert is_nil(node_exec.error)
+      assert %DateTime{} = node_exec.completed_at
+    end
+
+    test "record_node_completion with error", %{context: context} do
+      error = {:error, "Something went wrong"}
+
+      context =
+        context
+        |> Context.record_node_start("node_1")
+        |> Context.record_node_completion("node_1", error)
+
+      node_exec = Context.get_node_execution(context, "node_1")
+      assert node_exec.status == :failed
+      assert node_exec.error == "Something went wrong"
+    end
+
+    test "record_node_completion without prior start", %{context: context} do
+      # Should create a completed record even without start
+      context = Context.record_node_completion(context, "node_1", :ok)
+
+      node_exec = Context.get_node_execution(context, "node_1")
+      assert node_exec.status == :completed
+      assert %DateTime{} = node_exec.started_at
+      assert %DateTime{} = node_exec.completed_at
+    end
+  end
+
+  describe "tags and options" do
+    setup do
+      context =
+        Context.new("exec_123", "workflow_456",
+          tags: %{"env" => "prod", stage: "analysis"},
+          options: %{"timeout" => 5000, "retries" => 3}
+        )
+
+      {:ok, context: context}
+    end
+
+    test "get_tag with string key", %{context: context} do
+      assert Context.get_tag(context, "env") == "prod"
+    end
+
+    test "get_tag with atom key", %{context: context} do
+      assert Context.get_tag(context, :stage) == "analysis"
+    end
+
+    test "get_tag returns nil for missing key", %{context: context} do
+      assert Context.get_tag(context, "missing") == nil
+      assert Context.get_tag(context, :missing) == nil
+    end
+
+    test "get_option returns value", %{context: context} do
+      assert Context.get_option(context, "timeout") == 5000
+      assert Context.get_option(context, "retries") == 3
+    end
+
+    test "get_option returns default when missing", %{context: context} do
+      assert Context.get_option(context, "missing", "default") == "default"
+      assert Context.get_option(context, "missing") == nil
+    end
+  end
+
+  describe "metrics" do
+    setup do
+      context = Context.new("exec_123", "workflow_456")
+      {:ok, context: context}
+    end
+
+    test "record_metric sends telemetry event", %{context: context} do
+      # This test ensures the function doesn't crash
+      # In a real test, you might attach a telemetry handler to verify
+      assert :ok = Context.record_metric(context, "files_processed", 100)
+      assert :ok = Context.record_metric(context, "duration_ms", 1250)
+      assert :ok = Context.record_metric(context, "memory_mb", 45.5, %{node: "analyzer"})
+    end
+  end
+
+  describe "create_node_context" do
+    test "stores node id in process dictionary" do
+      context = Context.new("exec_123", "workflow_456")
+
+      # Ensure clean state
+      Process.delete(:current_node_id)
+
+      Context.create_node_context(context, "test_node")
+      assert Process.get(:current_node_id) == "test_node"
+
+      # Cleanup
+      Process.delete(:current_node_id)
+    end
+  end
+
+  describe "to_map" do
+    test "converts context to map for serialization" do
+      context =
+        Context.new("exec_123", "workflow_456",
+          workflow_name: "Test",
+          tags: %{env: "test"}
+        )
+
+      map = Context.to_map(context)
+
+      assert map.execution_id == "exec_123"
+      assert map.workflow_id == "workflow_456"
+      assert map.workflow_name == "Test"
+      assert map.tags == %{env: "test"}
+      assert Map.has_key?(map, :variables)
+      assert Map.has_key?(map, :start_time)
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/runtime/engine_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/runtime/engine_test.exs
new file mode 100644
index 0000000..16ab304
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/runtime/engine_test.exs
@@ -0,0 +1,560 @@
+defmodule GitlockWorkflows.Runtime.EngineTest do
+  use ExUnit.Case, async: false
+
+  alias GitlockWorkflows.Runtime.{Engine, Workflow, Registry}
+  alias GitlockWorkflows.Fixtures.Nodes.{TriggerNode, ProcessNode, ErrorNode}
+
+  setup do
+    # First ensure Registry is started (usually done by supervision tree)
+    unless GenServer.whereis(Registry) do
+      Registry.start_link()
+    end
+
+    # Register the existing fixture nodes
+    Registry.register_nodes([TriggerNode, ProcessNode, ErrorNode])
+
+    # Ensure Engine is started
+    case GenServer.whereis(Engine) do
+      nil -> Engine.start_link()
+      _pid -> :ok
+    end
+
+    on_exit(fn ->
+      # Clean up registered nodes
+      if GenServer.whereis(Registry) do
+        Registry.unregister_node("test.trigger")
+        Registry.unregister_node("test.process")
+        Registry.unregister_node("test.error")
+      end
+    end)
+
+    :ok
+  end
+
+  describe "start_link/1" do
+    test "engine starts and is accessible" do
+      assert pid = GenServer.whereis(Engine)
+      assert Process.alive?(pid)
+    end
+  end
+
+  describe "execute/3" do
+    test "executes workflow asynchronously" do
+      workflow = create_simple_workflow()
+
+      assert {:ok, execution_id} = Engine.execute(workflow, %{})
+      assert is_binary(execution_id)
+      assert String.starts_with?(execution_id, "exec_")
+    end
+
+    test "validates workflow before execution" do
+      # Invalid workflow - unknown node type
+      invalid_workflow = %Workflow{
+        id: "invalid",
+        name: "Invalid",
+        nodes: [
+          %{
+            id: "n1",
+            type: "unknown.node",
+            parameters: %{},
+            disabled: false,
+            position: [0, 0]
+          }
+        ],
+        connections: [],
+        settings: %{},
+        version: 1
+      }
+
+      assert {:error, {:validation_failed, errors}} = Engine.execute(invalid_workflow, %{})
+
+      assert Enum.any?(errors, fn
+               {:unknown_node_type, "n1", "unknown.node"} -> true
+               _ -> false
+             end)
+    end
+
+    test "rejects workflow without trigger nodes" do
+      # Workflow with only non-trigger nodes
+      no_trigger_workflow = %Workflow{
+        id: "no_trigger",
+        name: "No Trigger",
+        nodes: [
+          %{
+            id: "process",
+            type: "test.process",
+            parameters: %{},
+            disabled: false,
+            position: [0, 0]
+          }
+        ],
+        connections: [],
+        settings: %{},
+        version: 1
+      }
+
+      assert {:error, {:validation_failed, errors}} = Engine.execute(no_trigger_workflow, %{})
+      assert {:no_trigger_nodes} in errors
+    end
+
+    test "tracks execution state" do
+      workflow = create_simple_workflow()
+
+      {:ok, execution_id} = Engine.execute(workflow, %{})
+
+      # Give it a moment to start
+      :timer.sleep(100)
+
+      case Engine.get_execution_status(execution_id) do
+        {:ok, status} ->
+          assert status.id == execution_id
+          assert status.workflow_id == workflow.id
+          assert status.state in [:pending, :running, :completed, :failed]
+
+        {:error, :not_found} ->
+          # If execution completed very quickly, this is also acceptable
+          :ok
+      end
+    end
+  end
+
+  describe "execute_sync/3" do
+    test "blocks until workflow completes" do
+      workflow = create_simple_workflow()
+
+      start_time = System.monotonic_time(:millisecond)
+      result = Engine.execute_sync(workflow, %{}, timeout: 5000)
+      end_time = System.monotonic_time(:millisecond)
+
+      # Should have blocked for some time
+      assert end_time - start_time >= 0
+
+      case result do
+        {:ok, _} -> :ok
+        {:error, :timeout} -> :ok
+        other -> flunk("Unexpected result: #{inspect(other)}")
+      end
+    end
+
+    test "respects timeout" do
+      workflow = create_slow_workflow(1000)
+      assert {:error, :timeout} = Engine.execute_sync(workflow, %{}, timeout: 100)
+    end
+  end
+
+  describe "get_execution_status/1" do
+    test "returns detailed execution status" do
+      workflow = create_simple_workflow()
+      initial_data = %{test: "data"}
+
+      {:ok, execution_id} = Engine.execute(workflow, initial_data)
+
+      {:ok, status} = Engine.get_execution_status(execution_id)
+
+      assert status.id == execution_id
+      assert status.workflow_id == workflow.id
+      assert status.state in [:pending, :running, :completed, :failed]
+      assert is_float(status.progress)
+      assert status.progress >= 0.0 and status.progress <= 100.0
+      assert is_map(status.metrics)
+      assert status.metrics.nodes_total == length(workflow.nodes)
+    end
+
+    test "returns error for unknown execution" do
+      assert {:error, :not_found} = Engine.get_execution_status("unknown_exec_id")
+    end
+  end
+
+  describe "list_executions/1" do
+    test "returns all executions" do
+      workflow1 = create_simple_workflow()
+      workflow2 = create_simple_workflow()
+
+      {:ok, exec1} = Engine.execute(workflow1, %{})
+      {:ok, exec2} = Engine.execute(workflow2, %{})
+
+      executions = Engine.list_executions()
+      exec_ids = Enum.map(executions, & &1.id)
+
+      assert exec1 in exec_ids
+      assert exec2 in exec_ids
+    end
+
+    test "filters by workflow_id" do
+      workflow = create_simple_workflow()
+      {:ok, execution_id} = Engine.execute(workflow, %{})
+
+      :timer.sleep(50)
+
+      filtered = Engine.list_executions(%{workflow_id: workflow.id})
+      assert Enum.any?(filtered, fn e -> e.id == execution_id end)
+
+      assert [] = Engine.list_executions(%{workflow_id: "non_existent"})
+    end
+
+    test "filters by state" do
+      workflow = create_simple_workflow()
+      {:ok, _} = Engine.execute(workflow, %{})
+
+      :timer.sleep(100)
+
+      executions = Engine.list_executions()
+
+      if not Enum.empty?(executions) do
+        states = Enum.map(executions, & &1.state) |> Enum.uniq()
+
+        Enum.each(states, fn state ->
+          filtered = Engine.list_executions(%{state: state})
+          assert Enum.all?(filtered, fn e -> e.state == state end)
+        end)
+      end
+    end
+
+    test "applies limit and offset" do
+      workflow = create_simple_workflow()
+      for _ <- 1..5, do: Engine.execute(workflow, %{})
+
+      :timer.sleep(100)
+
+      limited = Engine.list_executions(%{limit: 2})
+      assert length(limited) <= 2
+
+      all = Engine.list_executions()
+      offset = Engine.list_executions(%{offset: 2})
+      assert length(offset) == max(0, length(all) - 2)
+    end
+  end
+
+  describe "subscribe_to_execution/1" do
+    test "receives execution events" do
+      workflow = create_simple_workflow()
+      {:ok, execution_id} = Engine.execute(workflow, %{})
+
+      assert :ok = Engine.subscribe_to_execution(execution_id)
+
+      receive do
+        {:execution_started, ^execution_id} -> :ok
+        {:execution_completed, ^execution_id, _result} -> :ok
+        {:execution_failed, ^execution_id, _error} -> :ok
+      after
+        1000 -> flunk("Should have received an execution event")
+      end
+    end
+
+    test "returns error for unknown execution" do
+      assert {:error, :not_found} = Engine.subscribe_to_execution("unknown_id")
+    end
+
+    test "handles multiple subscribers" do
+      workflow = create_simple_workflow()
+      {:ok, execution_id} = Engine.execute(workflow, %{})
+
+      task1 =
+        Task.async(fn ->
+          Engine.subscribe_to_execution(execution_id)
+
+          receive do
+            {_, ^execution_id} -> :ok
+            {_, ^execution_id, _} -> :ok
+          after
+            1000 -> :timeout
+          end
+        end)
+
+      task2 =
+        Task.async(fn ->
+          Engine.subscribe_to_execution(execution_id)
+
+          receive do
+            {_, ^execution_id} -> :ok
+            {_, ^execution_id, _} -> :ok
+          after
+            1000 -> :timeout
+          end
+        end)
+
+      assert Task.await(task1, 2000) == :ok
+      assert Task.await(task2, 2000) == :ok
+    end
+  end
+
+  describe "unsubscribe_from_execution/1" do
+    test "stops receiving events after unsubscribe" do
+      workflow = create_slow_workflow(500)
+      {:ok, execution_id} = Engine.execute(workflow, %{})
+
+      Engine.subscribe_to_execution(execution_id)
+      assert :ok = Engine.unsubscribe_from_execution(execution_id)
+      assert :ok = Engine.unsubscribe_from_execution(execution_id)
+    end
+  end
+
+  describe "get_stats/0" do
+    test "returns engine statistics" do
+      stats = Engine.get_stats()
+
+      assert is_map(stats)
+      assert Map.has_key?(stats, :total_executions)
+      assert Map.has_key?(stats, :successful_executions)
+      assert Map.has_key?(stats, :failed_executions)
+      assert Map.has_key?(stats, :success_rate)
+      assert Map.has_key?(stats, :active_executions)
+
+      assert is_number(stats.total_executions)
+      assert is_number(stats.successful_executions)
+      assert is_number(stats.failed_executions)
+      assert is_number(stats.success_rate)
+      assert is_number(stats.active_executions)
+    end
+
+    test "tracks global execution metrics" do
+      initial_stats = Engine.get_stats()
+      initial_total = initial_stats.total_executions
+
+      workflow = create_simple_workflow()
+      {:ok, _} = Engine.execute(workflow, %{})
+
+      :timer.sleep(100)
+      new_stats = Engine.get_stats()
+      assert new_stats.total_executions >= initial_total
+    end
+  end
+
+  describe "telemetry integration" do
+    test "telemetry events are properly handled" do
+      # Test that telemetry events are correctly processed
+      workflow = create_simple_workflow()
+      {:ok, execution_id} = Engine.execute(workflow, %{})
+
+      # Subscribe to execution events
+      :ok = Engine.subscribe_to_execution(execution_id)
+
+      # We should receive execution events
+      receive do
+        {:execution_started, ^execution_id} -> :ok
+        {:execution_completed, ^execution_id, _result} -> :ok
+        {:execution_failed, ^execution_id, _error} -> :ok
+      after
+        2000 -> flunk("Should have received execution events")
+      end
+
+      # Check that execution status is updated
+      {:ok, status} = Engine.get_execution_status(execution_id)
+      assert status.state in [:running, :completed, :failed]
+    end
+
+    test "node progress is tracked through telemetry" do
+      workflow = create_simple_workflow()
+      {:ok, execution_id} = Engine.execute(workflow, %{})
+
+      # Wait a bit for execution to progress
+      :timer.sleep(200)
+
+      case Engine.get_execution_status(execution_id) do
+        {:ok, status} ->
+          # Progress should be tracked
+          assert is_float(status.progress)
+          assert status.progress >= 0.0
+
+        {:error, :not_found} ->
+          # Execution may have completed quickly
+          :ok
+      end
+    end
+  end
+
+  describe "error handling" do
+    test "handles workflow execution errors gracefully" do
+      # Create a workflow that will fail
+      error_workflow = %Workflow{
+        id: "error_workflow",
+        name: "Error Workflow",
+        nodes: [
+          %{
+            id: "trigger",
+            type: "test.trigger",
+            parameters: %{},
+            disabled: false,
+            position: [0, 0]
+          },
+          %{
+            id: "error_node",
+            type: "test.error",
+            parameters: %{
+              "error_message" => "Test error"
+            },
+            disabled: false,
+            position: [100, 0]
+          }
+        ],
+        connections: [
+          %{
+            from: %{node: "trigger", port: "main"},
+            to: %{node: "error_node", port: "main"}
+          }
+        ],
+        settings: %{},
+        version: 1
+      }
+
+      {:ok, execution_id} = Engine.execute(error_workflow, %{})
+
+      # Wait for execution to complete
+      :timer.sleep(100)
+
+      case Engine.get_execution_status(execution_id) do
+        {:ok, status} ->
+          # Should handle error gracefully
+          assert status.state in [:failed, :completed]
+
+          if status.state == :failed do
+            assert status.error != nil
+          end
+
+        {:error, :not_found} ->
+          # Execution may have been cleaned up
+          :ok
+      end
+    end
+  end
+
+  describe "validation edge cases" do
+    test "detects cycles in workflow" do
+      cyclic_workflow = %Workflow{
+        id: "cyclic",
+        name: "Cyclic Workflow",
+        nodes: [
+          %{
+            id: "trigger",
+            type: "test.trigger",
+            parameters: %{},
+            disabled: false,
+            position: [0, 0]
+          },
+          %{
+            id: "node1",
+            type: "test.process",
+            parameters: %{},
+            disabled: false,
+            position: [100, 0]
+          },
+          %{
+            id: "node2",
+            type: "test.process",
+            parameters: %{},
+            disabled: false,
+            position: [200, 0]
+          }
+        ],
+        connections: [
+          %{from: %{node: "trigger", port: "main"}, to: %{node: "node1", port: "main"}},
+          %{from: %{node: "node1", port: "main"}, to: %{node: "node2", port: "main"}},
+          # Cycle!
+          %{from: %{node: "node2", port: "main"}, to: %{node: "node1", port: "main"}}
+        ],
+        settings: %{},
+        version: 1
+      }
+
+      assert {:error, {:validation_failed, errors}} = Engine.execute(cyclic_workflow, %{})
+
+      assert Enum.any?(errors, fn
+               {:cycle_detected, _path} -> true
+               _ -> false
+             end)
+    end
+
+    test "detects orphan nodes" do
+      orphan_workflow = %Workflow{
+        id: "orphan",
+        name: "Orphan Workflow",
+        nodes: [
+          %{
+            id: "trigger",
+            type: "test.trigger",
+            parameters: %{},
+            disabled: false,
+            position: [0, 0]
+          },
+          %{
+            id: "orphan",
+            type: "test.process",
+            parameters: %{},
+            disabled: false,
+            position: [100, 100]
+          }
+        ],
+        connections: [],
+        settings: %{},
+        version: 1
+      }
+
+      assert {:error, {:validation_failed, errors}} = Engine.execute(orphan_workflow, %{})
+      assert {:orphan_node, "orphan"} in errors
+    end
+  end
+
+  # Helper functions
+
+  defp create_simple_workflow do
+    %Workflow{
+      id: "test_workflow_#{:rand.uniform(10000)}",
+      name: "Test Workflow",
+      nodes: [
+        %{
+          id: "trigger",
+          type: "test.trigger",
+          parameters: %{},
+          disabled: false,
+          position: [0, 0]
+        },
+        %{
+          id: "process",
+          type: "test.process",
+          parameters: %{},
+          disabled: false,
+          position: [100, 0]
+        }
+      ],
+      connections: [
+        %{
+          from: %{node: "trigger", port: "main"},
+          to: %{node: "process", port: "main"}
+        }
+      ],
+      settings: %{},
+      version: 1
+    }
+  end
+
+  defp create_slow_workflow(delay_ms) do
+    %Workflow{
+      id: "slow_workflow_#{:rand.uniform(10000)}",
+      name: "Slow Workflow",
+      nodes: [
+        %{
+          id: "trigger",
+          type: "test.trigger",
+          parameters: %{},
+          disabled: false,
+          position: [0, 0]
+        },
+        %{
+          id: "slow_process",
+          type: "test.process",
+          parameters: %{"delay_ms" => delay_ms},
+          disabled: false,
+          position: [100, 0]
+        }
+      ],
+      connections: [
+        %{
+          from: %{node: "trigger", port: "main"},
+          to: %{node: "slow_process", port: "main"}
+        }
+      ],
+      settings: %{},
+      version: 1
+    }
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/runtime/node_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/runtime/node_test.exs
new file mode 100644
index 0000000..aa6e516
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/runtime/node_test.exs
@@ -0,0 +1,50 @@
+defmodule GitlockWorkflows.Runtime.NodeTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.Runtime.Node
+  alias GitlockWorkflows.Fixtures.Nodes.{TestNode, TargetNode}
+
+  # Test node implementation
+  setup do
+    # Register test nodes
+    :ok = GitlockWorkflows.Runtime.Registry.register_nodes([TestNode, TargetNode])
+
+    on_exit(fn ->
+      # Cleanup registered nodes
+      GitlockWorkflows.Runtime.Registry.unregister_node("test.node")
+      GitlockWorkflows.Runtime.Registry.unregister_node("test.target")
+    end)
+
+    :ok
+  end
+
+  describe "using macro" do
+    test "provides default reactor_options" do
+      assert TestNode.reactor_options() == []
+    end
+  end
+
+  describe "get_module/1" do
+    test "retrieves registered node module" do
+      assert {:ok, TestNode} = Node.get_module("test.node")
+    end
+
+    test "returns error for unknown node" do
+      assert {:error, :not_found} = Node.get_module("unknown.node")
+    end
+  end
+
+  describe "get_metadata/1" do
+    test "retrieves node metadata" do
+      assert {:ok, metadata} = Node.get_metadata("test.node")
+      assert metadata.id == "test.node"
+      assert metadata.displayName == "Test Node"
+      assert length(metadata.inputs) == 2
+      assert length(metadata.outputs) == 2
+    end
+
+    test "returns error for unknown node" do
+      assert {:error, :not_found} = Node.get_metadata("unknown.node")
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/runtime/nodes/logic_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/runtime/nodes/logic_test.exs
new file mode 100644
index 0000000..cd35e75
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/runtime/nodes/logic_test.exs
@@ -0,0 +1,322 @@
+defmodule GitlockWorkflows.Runtime.Nodes.LogicTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.Runtime.Nodes.Logic.{
+    Filter,
+    Sort,
+    Limit,
+    If,
+    Switch,
+    Merge,
+    Aggregate,
+    RemoveDuplicates,
+    GroupBy
+  }
+
+  @hotspots [
+    %{entity: "lib/core.ex", revisions: 50, risk_factor: "high", risk_score: 8.5},
+    %{entity: "lib/utils.ex", revisions: 10, risk_factor: "low", risk_score: 1.2},
+    %{entity: "lib/api.ex", revisions: 30, risk_factor: "medium", risk_score: 5.0},
+    %{entity: "lib/db.ex", revisions: 45, risk_factor: "high", risk_score: 7.8},
+    %{entity: "lib/auth.ex", revisions: 20, risk_factor: "medium", risk_score: 4.1}
+  ]
+
+  # ── Filter ───────────────────────────────────────────────────
+
+  describe "Filter" do
+    test "keeps items matching eq condition" do
+      {:ok, out} =
+        Filter.execute(
+          %{items: @hotspots},
+          %{"field" => "risk_factor", "operator" => "eq", "value" => "high"},
+          %{}
+        )
+
+      assert length(out.kept) == 2
+      assert length(out.rejected) == 3
+      assert Enum.all?(out.kept, &(&1.risk_factor == "high"))
+    end
+
+    test "numeric gt comparison" do
+      {:ok, out} =
+        Filter.execute(
+          %{items: @hotspots},
+          %{"field" => "revisions", "operator" => "gt", "value" => "25"},
+          %{}
+        )
+
+      assert length(out.kept) == 3
+      assert Enum.all?(out.kept, &(&1.revisions > 25))
+    end
+
+    test "contains string matching" do
+      {:ok, out} =
+        Filter.execute(
+          %{items: @hotspots},
+          %{"field" => "entity", "operator" => "contains", "value" => "core"},
+          %{}
+        )
+
+      assert length(out.kept) == 1
+      assert hd(out.kept).entity == "lib/core.ex"
+    end
+
+    test "empty field returns error" do
+      assert {:error, _} =
+               Filter.execute(
+                 %{items: @hotspots},
+                 %{"field" => "", "operator" => "eq", "value" => "x"},
+                 %{}
+               )
+    end
+  end
+
+  # ── Sort ─────────────────────────────────────────────────────
+
+  describe "Sort" do
+    test "sorts ascending by numeric field" do
+      {:ok, out} =
+        Sort.execute(%{items: @hotspots}, %{"field" => "revisions", "direction" => "asc"}, %{})
+
+      revisions = Enum.map(out.items, & &1.revisions)
+      assert revisions == Enum.sort(revisions)
+    end
+
+    test "sorts descending" do
+      {:ok, out} =
+        Sort.execute(%{items: @hotspots}, %{"field" => "risk_score", "direction" => "desc"}, %{})
+
+      scores = Enum.map(out.items, & &1.risk_score)
+      assert scores == Enum.sort(scores, :desc)
+    end
+  end
+
+  # ── Limit ────────────────────────────────────────────────────
+
+  describe "Limit" do
+    test "takes first N items" do
+      {:ok, out} = Limit.execute(%{items: @hotspots}, %{"count" => 2, "from" => "start"}, %{})
+      assert length(out.items) == 2
+      assert out.items == Enum.take(@hotspots, 2)
+    end
+
+    test "takes last N items" do
+      {:ok, out} = Limit.execute(%{items: @hotspots}, %{"count" => 2, "from" => "end"}, %{})
+      assert length(out.items) == 2
+      assert out.items == Enum.take(@hotspots, -2)
+    end
+
+    test "handles count larger than list" do
+      {:ok, out} = Limit.execute(%{items: @hotspots}, %{"count" => 100}, %{})
+      assert length(out.items) == 5
+    end
+  end
+
+  # ── IF ───────────────────────────────────────────────────────
+
+  describe "IF" do
+    test "splits items into true/false branches" do
+      {:ok, out} =
+        If.execute(
+          %{items: @hotspots},
+          %{"field" => "risk_factor", "operator" => "eq", "value" => "high"},
+          %{}
+        )
+
+      assert length(out.true) == 2
+      assert length(out.false) == 3
+    end
+
+    test "numeric gte condition" do
+      {:ok, out} =
+        If.execute(
+          %{items: @hotspots},
+          %{"field" => "revisions", "operator" => "gte", "value" => "30"},
+          %{}
+        )
+
+      assert length(out.true) == 3
+      assert Enum.all?(out.true, &(&1.revisions >= 30))
+    end
+
+    test "is_empty check" do
+      items = [%{name: "a", value: nil}, %{name: "b", value: "x"}, %{name: "c", value: ""}]
+
+      {:ok, out} =
+        If.execute(%{items: items}, %{"field" => "value", "operator" => "is_empty"}, %{})
+
+      assert length(out.true) == 2
+      assert length(out.false) == 1
+    end
+  end
+
+  # ── Switch ───────────────────────────────────────────────────
+
+  describe "Switch" do
+    test "routes items to named cases" do
+      {:ok, out} =
+        Switch.execute(
+          %{items: @hotspots},
+          %{"field" => "risk_factor", "cases" => "high,medium,low"},
+          %{}
+        )
+
+      # high
+      assert length(out.case_0) == 2
+      # medium
+      assert length(out.case_1) == 2
+      # low
+      assert length(out.case_2) == 1
+      assert out.default == []
+    end
+
+    test "unmatched items go to default" do
+      {:ok, out} =
+        Switch.execute(
+          %{items: @hotspots},
+          %{"field" => "risk_factor", "cases" => "critical"},
+          %{}
+        )
+
+      assert out.case_0 == []
+      assert length(out.default) == 5
+    end
+  end
+
+  # ── Merge ────────────────────────────────────────────────────
+
+  describe "Merge" do
+    test "appends two lists" do
+      a = [%{n: 1}, %{n: 2}]
+      b = [%{n: 3}, %{n: 4}]
+      {:ok, out} = Merge.execute(%{items_a: a, items_b: b}, %{"mode" => "append"}, %{})
+      assert length(out.items) == 4
+      assert Enum.map(out.items, & &1.n) == [1, 2, 3, 4]
+    end
+
+    test "interleaves two lists" do
+      a = [%{n: 1}, %{n: 2}]
+      b = [%{n: 3}, %{n: 4}]
+      {:ok, out} = Merge.execute(%{items_a: a, items_b: b}, %{"mode" => "interleave"}, %{})
+      assert Enum.map(out.items, & &1.n) == [1, 3, 2, 4]
+    end
+
+    test "handles nil items_b" do
+      {:ok, out} = Merge.execute(%{items_a: [%{n: 1}]}, %{"mode" => "append"}, %{})
+      assert length(out.items) == 1
+    end
+  end
+
+  # ── Aggregate ────────────────────────────────────────────────
+
+  describe "Aggregate" do
+    test "computes count" do
+      {:ok, out} = Aggregate.execute(%{items: @hotspots}, %{"operations" => "count"}, %{})
+      assert out.result["count"] == 5
+    end
+
+    test "computes sum and avg" do
+      {:ok, out} =
+        Aggregate.execute(
+          %{items: @hotspots},
+          %{"operations" => "sum:revisions,avg:revisions"},
+          %{}
+        )
+
+      assert out.result["sum_revisions"] == 155
+      assert_in_delta out.result["avg_revisions"], 31.0, 0.01
+    end
+
+    test "computes min and max" do
+      {:ok, out} =
+        Aggregate.execute(
+          %{items: @hotspots},
+          %{"operations" => "min:risk_score,max:risk_score"},
+          %{}
+        )
+
+      assert out.result["min_risk_score"] == 1.2
+      assert out.result["max_risk_score"] == 8.5
+    end
+
+    test "multiple operations in one call" do
+      {:ok, out} =
+        Aggregate.execute(
+          %{items: @hotspots},
+          %{"operations" => "count,sum:revisions,max:risk_score"},
+          %{}
+        )
+
+      assert out.result["count"] == 5
+      assert out.result["sum_revisions"] == 155
+      assert out.result["max_risk_score"] == 8.5
+    end
+  end
+
+  # ── Remove Duplicates ───────────────────────────────────────
+
+  describe "RemoveDuplicates" do
+    test "removes duplicates by field" do
+      items = [
+        %{entity: "a.ex", author: "alice"},
+        %{entity: "b.ex", author: "bob"},
+        %{entity: "c.ex", author: "alice"},
+        %{entity: "d.ex", author: "alice"}
+      ]
+
+      {:ok, out} = RemoveDuplicates.execute(%{items: items}, %{"field" => "author"}, %{})
+      assert length(out.items) == 2
+      authors = Enum.map(out.items, & &1.author)
+      assert "alice" in authors
+      assert "bob" in authors
+    end
+  end
+
+  # ── Group By ─────────────────────────────────────────────────
+
+  describe "GroupBy" do
+    test "groups items by field" do
+      {:ok, out} = GroupBy.execute(%{items: @hotspots}, %{"field" => "risk_factor"}, %{})
+
+      assert map_size(out.groups) == 3
+      assert length(out.groups["high"]) == 2
+      assert length(out.groups["medium"]) == 2
+      assert length(out.groups["low"]) == 1
+    end
+
+    test "outputs sorted summaries" do
+      {:ok, out} = GroupBy.execute(%{items: @hotspots}, %{"field" => "risk_factor"}, %{})
+
+      assert length(out.items) == 3
+      [first | _] = out.items
+      assert Map.has_key?(first, :group)
+      assert Map.has_key?(first, :count)
+    end
+  end
+
+  # ── Catalog integration ──────────────────────────────────────
+
+  describe "NodeCatalog integration" do
+    test "all logic nodes are in the catalog" do
+      logic = GitlockWorkflows.NodeCatalog.by_category(:logic)
+      type_ids = Enum.map(logic, & &1.type_id) |> MapSet.new()
+
+      for expected <-
+            ~w(filter sort limit if_condition switch merge aggregate remove_duplicates group_by)a do
+        assert MapSet.member?(type_ids, expected), "Missing logic node: #{expected}"
+      end
+    end
+
+    test "all logic nodes have runtime modules" do
+      for type_def <- GitlockWorkflows.NodeCatalog.by_category(:logic) do
+        assert type_def.runtime_module != nil, "#{type_def.type_id} missing runtime_module"
+      end
+    end
+
+    test "serializer catalog includes Logic category" do
+      catalog = GitlockWorkflows.Serializer.catalog_to_list()
+      categories = Enum.map(catalog, & &1.name)
+      assert "Logic" in categories
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/runtime/registry_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/runtime/registry_test.exs
new file mode 100644
index 0000000..32e85f0
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/runtime/registry_test.exs
@@ -0,0 +1,394 @@
+defmodule GitlockWorkflows.Runtime.RegistryTest do
+  use ExUnit.Case, async: false
+
+  alias GitlockWorkflows.Runtime.Registry
+  alias GitlockWorkflows.Fixtures.Nodes
+
+  # Invalid node for testing
+  defmodule InvalidNode do
+    # Deliberately missing required functions
+    def some_function, do: :ok
+  end
+
+  setup do
+    # Store initial registry state
+    initial_nodes = Registry.list_nodes()
+    initial_node_ids = Enum.map(initial_nodes, & &1.id)
+
+    # Clean up any previously registered test nodes
+    on_exit(fn ->
+      # Get current nodes
+      current_nodes = Registry.list_nodes()
+
+      # Remove any nodes that weren't there initially
+      Enum.each(current_nodes, fn node ->
+        unless node.id in initial_node_ids do
+          Registry.unregister_node(node.id)
+        end
+      end)
+    end)
+
+    :ok
+  end
+
+  describe "start_link/1" do
+    test "registry starts successfully" do
+      # Registry should already be started by the application
+      assert Process.whereis(Registry) != nil
+    end
+  end
+
+  describe "register_node/1" do
+    test "registers a valid node successfully" do
+      assert :ok = Registry.register_node(Nodes.ValidNode)
+
+      # Verify registration
+      assert {:ok, Nodes.ValidNode} = Registry.get_node("test.valid")
+    end
+
+    test "handles metadata normalization" do
+      defmodule PartialNode do
+        use GitlockWorkflows.Runtime.Node
+
+        def metadata do
+          %{
+            id: "test.partial",
+            # Missing displayName, should default to id
+            # Missing group, should default to "other"
+            version: 1,
+            description: "Test",
+            inputs: [],
+            outputs: [],
+            parameters: []
+          }
+        end
+
+        def execute(_, _, _), do: {:ok, %{}}
+        def validate_parameters(_), do: :ok
+      end
+
+      assert :ok = Registry.register_node(PartialNode)
+      assert {:ok, metadata} = Registry.get_metadata("test.partial")
+
+      # Defaults to id
+      assert metadata.displayName == "test.partial"
+      # Default group
+      assert metadata.group == "other"
+      # Default empty
+      assert metadata.tags == []
+      assert metadata.deprecated == false
+      assert metadata.experimental == false
+    end
+
+    test "returns error for invalid node" do
+      assert {:error, errors} = Registry.register_node(InvalidNode)
+
+      assert Enum.any?(errors, fn
+               {:missing_function, _} -> true
+               _ -> false
+             end)
+    end
+
+    test "returns error for node with invalid metadata" do
+      defmodule BadMetadataNode do
+        use GitlockWorkflows.Runtime.Node
+
+        def metadata do
+          %{
+            # Missing required id field
+            displayName: "Bad Node",
+            group: "test",
+            version: 1,
+            description: "Invalid",
+            # Should be a list
+            inputs: "not a list",
+            outputs: [],
+            parameters: []
+          }
+        end
+
+        def execute(_, _, _), do: {:ok, %{}}
+        def validate_parameters(_), do: :ok
+      end
+
+      assert {:error, errors} = Registry.register_node(BadMetadataNode)
+
+      assert Enum.any?(errors, fn
+               {:invalid_id, _} -> true
+               {:invalid_metadata, _} -> true
+               _ -> false
+             end)
+    end
+  end
+
+  describe "register_nodes/1" do
+    test "registers multiple nodes successfully" do
+      assert :ok = Registry.register_nodes([Nodes.ValidNode, Nodes.MinimalNode])
+
+      assert {:ok, Nodes.ValidNode} = Registry.get_node("test.valid")
+      assert {:ok, Nodes.MinimalNode} = Registry.get_node("test.minimal")
+    end
+
+    test "returns errors for failed registrations" do
+      assert {:error, failures} =
+               Registry.register_nodes([Nodes.ValidNode, InvalidNode, Nodes.MinimalNode])
+
+      # ValidNode and MinimalNode should succeed
+      assert {:ok, Nodes.ValidNode} = Registry.get_node("test.valid")
+      assert {:ok, Nodes.MinimalNode} = Registry.get_node("test.minimal")
+
+      # InvalidNode should be in failures
+      assert Map.has_key?(failures, InvalidNode)
+    end
+  end
+
+  describe "get_node/1" do
+    setup do
+      Registry.register_node(Nodes.ValidNode)
+      :ok
+    end
+
+    test "returns module for registered node" do
+      assert {:ok, Nodes.ValidNode} = Registry.get_node("test.valid")
+    end
+
+    test "returns error for unknown node" do
+      assert {:error, :not_found} = Registry.get_node("unknown.node")
+    end
+  end
+
+  describe "get_metadata/1" do
+    setup do
+      Registry.register_node(Nodes.ValidNode)
+      :ok
+    end
+
+    test "returns metadata for registered node" do
+      assert {:ok, metadata} = Registry.get_metadata("test.valid")
+      assert metadata.id == "test.valid"
+      assert metadata.displayName == "Valid Test Node"
+      assert metadata.experimental == true
+    end
+
+    test "returns error for unknown node" do
+      assert {:error, :not_found} = Registry.get_metadata("unknown.node")
+    end
+  end
+
+  describe "list_nodes/0" do
+    test "returns empty list when no nodes registered" do
+      # Clear any existing nodes
+      nodes = Registry.list_nodes()
+
+      Enum.each(nodes, fn node ->
+        Registry.unregister_node(node.id)
+      end)
+
+      assert Registry.list_nodes() == []
+    end
+
+    test "returns all registered nodes sorted by display name" do
+      Registry.register_nodes([Nodes.MinimalNode, Nodes.ValidNode])
+
+      nodes = Registry.list_nodes()
+      node_ids = Enum.map(nodes, & &1.id)
+
+      assert "test.minimal" in node_ids
+      assert "test.valid" in node_ids
+
+      # Check sorting
+      display_names = Enum.map(nodes, & &1.displayName)
+      assert display_names == Enum.sort(display_names)
+    end
+  end
+
+  describe "list_nodes_by_category/1" do
+    setup do
+      Registry.register_nodes([Nodes.ValidNode, Nodes.MinimalNode, Nodes.AnalysisNode])
+      :ok
+    end
+
+    test "returns nodes in specified category" do
+      test_nodes = Registry.list_nodes_by_category("test")
+      assert length(test_nodes) >= 2
+      assert Enum.all?(test_nodes, fn node -> node.group == "test" end)
+
+      analysis_nodes = Registry.list_nodes_by_category("analysis")
+      assert length(analysis_nodes) >= 1
+      assert Enum.all?(analysis_nodes, fn node -> node.group == "analysis" end)
+    end
+
+    test "returns empty list for unknown category" do
+      assert Registry.list_nodes_by_category("unknown") == []
+    end
+  end
+
+  describe "list_categories/0" do
+    setup do
+      Registry.register_nodes([Nodes.ValidNode, Nodes.MinimalNode])
+      :ok
+    end
+
+    test "returns sorted list of categories" do
+      categories = Registry.list_categories()
+      assert "test" in categories
+      assert categories == Enum.sort(categories)
+    end
+  end
+
+  describe "search_nodes/1" do
+    setup do
+      Registry.register_nodes([Nodes.ValidNode, Nodes.SearchableNode])
+      :ok
+    end
+
+    test "searches by id" do
+      results = Registry.search_nodes("searchable")
+      assert length(results) >= 1
+      assert Enum.any?(results, fn node -> node.id == "test.searchable" end)
+    end
+
+    test "searches by display name" do
+      results = Registry.search_nodes("hotspot")
+      assert length(results) >= 1
+      assert Enum.any?(results, fn node -> node.displayName == "Hotspot Analyzer" end)
+    end
+
+    test "searches by description" do
+      results = Registry.search_nodes("analyzes")
+      assert length(results) >= 1
+    end
+
+    test "searches by tags" do
+      results = Registry.search_nodes("git")
+      assert length(results) >= 1
+    end
+
+    test "search is case insensitive" do
+      results1 = Registry.search_nodes("HOTSPOT")
+      results2 = Registry.search_nodes("hotspot")
+      assert length(results1) == length(results2)
+    end
+
+    test "returns empty list for no matches" do
+      assert Registry.search_nodes("nonexistent") == []
+    end
+  end
+
+  describe "validate_node/1" do
+    test "validates correct node" do
+      assert :ok = Registry.validate_node(Nodes.ValidNode)
+    end
+
+    test "returns errors for invalid node" do
+      assert {:error, errors} = Registry.validate_node(InvalidNode)
+      assert is_list(errors)
+      assert length(errors) > 0
+    end
+
+    test "checks for required functions" do
+      defmodule MissingExecute do
+        def metadata do
+          %{
+            id: "test.missing",
+            displayName: "Missing Execute",
+            group: "test",
+            version: 1,
+            description: "Test",
+            inputs: [],
+            outputs: [],
+            parameters: []
+          }
+        end
+
+        def validate_parameters(_), do: :ok
+      end
+
+      assert {:error, errors} = Registry.validate_node(MissingExecute)
+
+      assert Enum.any?(errors, fn
+               {:missing_function, :execute} -> true
+               _ -> false
+             end)
+    end
+  end
+
+  describe "get_stats/0" do
+    test "returns registry statistics" do
+      # Clear registry first
+      nodes = Registry.list_nodes()
+
+      Enum.each(nodes, fn node ->
+        Registry.unregister_node(node.id)
+      end)
+
+      # Register known nodes
+      Registry.register_nodes([Nodes.ValidNode, Nodes.MinimalNode])
+
+      stats = Registry.get_stats()
+
+      assert stats.total_nodes >= 2
+      assert stats.nodes_by_group["test"] >= 2
+      assert %DateTime{} = stats.last_updated
+    end
+  end
+
+  describe "unregister_node/1" do
+    setup do
+      Registry.register_node(Nodes.ValidNode)
+      :ok
+    end
+
+    test "removes registered node" do
+      assert {:ok, Nodes.ValidNode} = Registry.get_node("test.valid")
+      assert :ok = Registry.unregister_node("test.valid")
+      assert {:error, :not_found} = Registry.get_node("test.valid")
+    end
+
+    test "returns error for unknown node" do
+      assert {:error, :not_found} = Registry.unregister_node("unknown.node")
+    end
+
+    test "updates statistics after removal" do
+      initial_stats = Registry.get_stats()
+      initial_count = initial_stats.total_nodes
+
+      Registry.unregister_node("test.valid")
+
+      new_stats = Registry.get_stats()
+      assert new_stats.total_nodes == initial_count - 1
+    end
+  end
+
+  describe "search index" do
+    test "builds search index from node metadata" do
+      defmodule IndexTestNode do
+        use GitlockWorkflows.Runtime.Node
+
+        def metadata do
+          %{
+            id: "test.index_node",
+            displayName: "Complex Test Node",
+            group: "testing",
+            version: 1,
+            description: "This node tests indexing",
+            inputs: [],
+            outputs: [],
+            parameters: [],
+            tags: ["index", "search", "test"]
+          }
+        end
+
+        def execute(_, _, _), do: {:ok, %{}}
+        def validate_parameters(_), do: :ok
+      end
+
+      Registry.register_node(IndexTestNode)
+
+      # Should find by various terms
+      assert length(Registry.search_nodes("complex")) >= 1
+      assert length(Registry.search_nodes("index")) >= 1
+      assert length(Registry.search_nodes("testing")) >= 1
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/runtime/validator_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/runtime/validator_test.exs
new file mode 100644
index 0000000..84bab1e
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/runtime/validator_test.exs
@@ -0,0 +1,896 @@
+defmodule GitlockWorkflows.Runtime.ValidatorTest do
+  use ExUnit.Case, async: false
+
+  alias GitlockWorkflows.Runtime.{Validator, Workflow, Registry}
+  alias GitlockWorkflows.Fixtures.Nodes.{TriggerNode, ProcessNode, OutputNode}
+
+  # Test nodes for validation scenarios
+  defmodule StringOutputNode do
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.string_output",
+        displayName: "String Output Node",
+        group: "test",
+        version: 1,
+        description: "Outputs string data",
+        inputs: [%{name: "main", type: :any, required: true}],
+        outputs: [%{name: "text", type: :string, required: false}],
+        parameters: [
+          %{name: "prefix", displayName: "Prefix", type: "string", default: "", required: false}
+        ]
+      }
+    end
+
+    @impl true
+    def execute(_input_data, parameters, _context) do
+      prefix = Map.get(parameters, "prefix", "")
+      {:ok, %{"text" => "#{prefix}processed"}}
+    end
+
+    @impl true
+    def validate_parameters(parameters) do
+      case Map.get(parameters, "prefix") do
+        nil -> :ok
+        value when is_binary(value) -> :ok
+        _ -> {:error, [{:invalid_type, "prefix"}]}
+      end
+    end
+  end
+
+  defmodule NumberInputNode do
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.number_input",
+        displayName: "Number Input Node",
+        group: "test",
+        version: 1,
+        description: "Requires number input",
+        inputs: [%{name: "value", type: :number, required: true}],
+        outputs: [%{name: "main", type: :any, required: false}],
+        parameters: [
+          %{
+            name: "threshold",
+            displayName: "Threshold",
+            type: "number",
+            default: 10,
+            required: true,
+            min: 1,
+            max: 100
+          }
+        ]
+      }
+    end
+
+    @impl true
+    def execute(_input_data, _parameters, _context) do
+      {:ok, %{"main" => "processed"}}
+    end
+
+    @impl true
+    def validate_parameters(parameters) do
+      case Map.get(parameters, "threshold") do
+        nil ->
+          {:error, [{:missing_required_parameter, "threshold"}]}
+
+        value when is_number(value) and value >= 1 and value <= 100 ->
+          :ok
+
+        value when is_number(value) ->
+          {:error, [{:invalid_parameter_value, "threshold", "out of range"}]}
+
+        _ ->
+          {:error, [{:invalid_parameter_type, "threshold", "number"}]}
+      end
+    end
+  end
+
+  defmodule RequiredParamsNode do
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.required_params",
+        displayName: "Required Params Node",
+        group: "test",
+        version: 1,
+        description: "Node with required parameters",
+        inputs: [%{name: "main", type: :any, required: true}],
+        outputs: [%{name: "main", type: :any, required: false}],
+        parameters: [
+          %{
+            name: "required_string",
+            displayName: "Required String",
+            type: "string",
+            required: true
+          },
+          %{
+            name: "required_number",
+            displayName: "Required Number",
+            type: "number",
+            required: true
+          },
+          %{
+            name: "optional_param",
+            displayName: "Optional",
+            type: "string",
+            required: false,
+            default: "default"
+          }
+        ]
+      }
+    end
+
+    @impl true
+    def execute(_input_data, _parameters, _context) do
+      {:ok, %{"main" => "processed"}}
+    end
+
+    @impl true
+    def validate_parameters(parameters) do
+      errors = []
+
+      # Check required string
+      errors =
+        case Map.get(parameters, "required_string") do
+          nil -> [{:missing_required_parameter, "required_string"} | errors]
+          value when is_binary(value) -> errors
+          _ -> [{:invalid_parameter_type, "required_string", "string"} | errors]
+        end
+
+      # Check required number
+      errors =
+        case Map.get(parameters, "required_number") do
+          nil -> [{:missing_required_parameter, "required_number"} | errors]
+          value when is_number(value) -> errors
+          _ -> [{:invalid_parameter_type, "required_number", "number"} | errors]
+        end
+
+      if errors == [], do: :ok, else: {:error, Enum.reverse(errors)}
+    end
+  end
+
+  setup do
+    # Register test nodes
+    Registry.register_nodes([
+      TriggerNode,
+      ProcessNode,
+      OutputNode,
+      StringOutputNode,
+      NumberInputNode,
+      RequiredParamsNode
+    ])
+
+    on_exit(fn ->
+      # Cleanup
+      Registry.unregister_node("test.trigger")
+      Registry.unregister_node("test.process")
+      Registry.unregister_node("test.output")
+      Registry.unregister_node("test.string_output")
+      Registry.unregister_node("test.number_input")
+      Registry.unregister_node("test.required_params")
+    end)
+
+    :ok
+  end
+
+  describe "validate_workflow/1" do
+    test "validates simple valid workflow" do
+      workflow = create_simple_valid_workflow()
+      assert {:ok, ^workflow} = Validator.validate_workflow(workflow)
+    end
+
+    test "returns all validation errors" do
+      # Create a workflow with multiple issues
+      invalid_workflow = %Workflow{
+        id: "invalid",
+        name: "Invalid Workflow",
+        nodes: [
+          # Unknown node type
+          %{
+            id: "bad_node",
+            type: "unknown.type",
+            parameters: %{},
+            disabled: false,
+            position: [0, 0]
+          },
+          # Duplicate ID
+          %{
+            id: "dup_id",
+            type: "test.trigger",
+            parameters: %{},
+            disabled: false,
+            position: [0, 0]
+          },
+          %{
+            id: "dup_id",
+            type: "test.process",
+            parameters: %{},
+            disabled: false,
+            position: [100, 0]
+          },
+          # Missing required parameters
+          %{
+            id: "missing_params",
+            type: "test.required_params",
+            parameters: %{},
+            disabled: false,
+            position: [200, 0]
+          }
+        ],
+        connections: [
+          # Connection to non-existent node
+          %{from: %{node: "bad_node", port: "main"}, to: %{node: "missing_node", port: "main"}}
+        ],
+        settings: %{},
+        version: 1
+      }
+
+      assert {:error, errors} = Validator.validate_workflow(invalid_workflow)
+      assert is_list(errors)
+      assert length(errors) > 0
+
+      # Should contain multiple error types
+      error_types = Enum.map(errors, fn error -> elem(error, 0) end)
+      assert :duplicate_node_id in error_types
+      assert :unknown_node_type in error_types
+      assert :missing_required_parameter in error_types
+    end
+  end
+
+  describe "validate_structure/1" do
+    test "rejects empty workflow" do
+      empty_workflow = %Workflow{nodes: [], connections: []}
+      assert {:error, [{:empty_workflow}]} = Validator.validate_structure(empty_workflow)
+    end
+
+    test "detects duplicate node IDs" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.trigger"},
+          # Duplicate ID
+          %{id: "node1", type: "test.process"}
+        ],
+        connections: []
+      }
+
+      assert {:error, errors} = Validator.validate_structure(workflow)
+      assert {:duplicate_node_id, "node1"} in errors
+    end
+
+    test "detects duplicate connections" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.trigger"},
+          %{id: "node2", type: "test.process"}
+        ],
+        connections: [
+          %{from: %{node: "node1", port: "main"}, to: %{node: "node2", port: "main"}},
+          # Duplicate
+          %{from: %{node: "node1", port: "main"}, to: %{node: "node2", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_structure(workflow)
+      assert {:duplicate_connection, "node1.main", "node2.main"} in errors
+    end
+
+    test "passes valid structure" do
+      workflow = create_simple_valid_workflow()
+      assert {:ok, ^workflow} = Validator.validate_structure(workflow)
+    end
+  end
+
+  describe "validate_nodes/1" do
+    test "validates all nodes successfully" do
+      workflow = create_simple_valid_workflow()
+      assert {:ok, ^workflow} = Validator.validate_nodes(workflow)
+    end
+
+    test "skips disabled nodes" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "enabled", type: "test.trigger", parameters: %{}, disabled: false},
+          # Would fail if checked
+          %{id: "disabled", type: "unknown.type", parameters: %{}, disabled: true}
+        ],
+        connections: []
+      }
+
+      assert {:ok, ^workflow} = Validator.validate_nodes(workflow)
+    end
+
+    test "detects unknown node types" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "unknown", type: "unknown.type", parameters: %{}, disabled: false}
+        ],
+        connections: []
+      }
+
+      assert {:error, errors} = Validator.validate_nodes(workflow)
+      assert {:unknown_node_type, "unknown", "unknown.type"} in errors
+    end
+  end
+
+  describe "validate_single_node/2" do
+    test "validates node with correct parameters" do
+      node = %{
+        id: "test",
+        type: "test.required_params",
+        parameters: %{
+          "required_string" => "test",
+          "required_number" => 42
+        }
+      }
+
+      errors = Validator.validate_single_node(node, %Workflow{})
+      assert errors == []
+    end
+
+    test "detects missing required parameters" do
+      node = %{id: "test", type: "test.required_params", parameters: %{}}
+
+      errors = Validator.validate_single_node(node, %Workflow{})
+      assert {:missing_required_parameter, "test", "required_string"} in errors
+      assert {:missing_required_parameter, "test", "required_number"} in errors
+    end
+
+    test "detects invalid parameter types" do
+      node = %{
+        id: "test",
+        type: "test.number_input",
+        parameters: %{
+          "threshold" => "not_a_number"
+        }
+      }
+
+      errors = Validator.validate_single_node(node, %Workflow{})
+      assert [{:invalid_parameter_type, "test", "threshold", "number", _}] = errors
+    end
+
+    test "detects out-of-range parameter values" do
+      node = %{
+        id: "test",
+        type: "test.number_input",
+        parameters: %{
+          # max is 100
+          "threshold" => 150
+        }
+      }
+
+      errors = Validator.validate_single_node(node, %Workflow{})
+      assert [{:invalid_parameter_value, "test", "threshold", _}] = errors
+    end
+  end
+
+  describe "validate_connections/1" do
+    test "validates all connections successfully" do
+      workflow = create_workflow_with_connections()
+      assert {:ok, ^workflow} = Validator.validate_connections(workflow)
+    end
+
+    test "detects missing from node" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node2", type: "test.process"}
+        ],
+        connections: [
+          %{from: %{node: "missing", port: "main"}, to: %{node: "node2", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_connections(workflow)
+      assert {:connection_missing_from_node, "missing"} in errors
+    end
+
+    test "detects missing to node" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.trigger"}
+        ],
+        connections: [
+          %{from: %{node: "node1", port: "main"}, to: %{node: "missing", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_connections(workflow)
+      assert {:connection_missing_to_node, "missing"} in errors
+    end
+
+    test "detects unknown output port" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.trigger", disabled: false},
+          %{id: "node2", type: "test.process", disabled: false}
+        ],
+        connections: [
+          %{from: %{node: "node1", port: "unknown_port"}, to: %{node: "node2", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_connections(workflow)
+      assert {:unknown_output_port, "node1", "unknown_port"} in errors
+    end
+
+    test "detects unknown input port" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.trigger", disabled: false},
+          %{id: "node2", type: "test.process", disabled: false}
+        ],
+        connections: [
+          %{from: %{node: "node1", port: "main"}, to: %{node: "node2", port: "unknown_port"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_connections(workflow)
+      assert {:unknown_input_port, "node2", "unknown_port"} in errors
+    end
+
+    test "detects incompatible port types" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "string_out", type: "test.string_output", disabled: false},
+          %{id: "number_in", type: "test.number_input", disabled: false}
+        ],
+        connections: [
+          # String output -> Number input (incompatible)
+          %{from: %{node: "string_out", port: "text"}, to: %{node: "number_in", port: "value"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_connections(workflow)
+      assert length(errors) > 0
+
+      # Should have incompatible port types error
+      assert Enum.any?(errors, fn
+               {:incompatible_port_types, _, _, _} -> true
+               _ -> false
+             end)
+    end
+  end
+
+  describe "check_port_compatibility/2" do
+    test "any type is compatible with everything" do
+      any_port = %{type: :any}
+      string_port = %{type: :string}
+
+      assert :compatible = Validator.check_port_compatibility(any_port, string_port)
+      assert :compatible = Validator.check_port_compatibility(string_port, any_port)
+    end
+
+    test "exact type matches are compatible" do
+      string_port = %{type: :string}
+      number_port = %{type: :number}
+
+      assert :compatible = Validator.check_port_compatibility(string_port, string_port)
+      assert :compatible = Validator.check_port_compatibility(number_port, number_port)
+    end
+
+    test "incompatible simple types" do
+      string_port = %{type: :string}
+      number_port = %{type: :number}
+
+      assert {:incompatible, _} = Validator.check_port_compatibility(string_port, number_port)
+    end
+
+    test "list type compatibility" do
+      string_list = %{type: {:list, :string}}
+      number_list = %{type: {:list, :number}}
+      any_list = %{type: {:list, :any}}
+
+      assert :compatible = Validator.check_port_compatibility(string_list, string_list)
+      assert :compatible = Validator.check_port_compatibility(string_list, any_list)
+      assert {:incompatible, _} = Validator.check_port_compatibility(string_list, number_list)
+    end
+
+    test "map type compatibility" do
+      string_map = %{type: {:map, :string}}
+      number_map = %{type: {:map, :number}}
+      any_map = %{type: {:map, :any}}
+
+      assert :compatible = Validator.check_port_compatibility(string_map, string_map)
+      assert :compatible = Validator.check_port_compatibility(string_map, any_map)
+      assert {:incompatible, _} = Validator.check_port_compatibility(string_map, number_map)
+    end
+  end
+
+  describe "validate_topology/1" do
+    test "validates acyclic workflow" do
+      workflow = create_workflow_with_connections()
+      assert {:ok, ^workflow} = Validator.validate_topology(workflow)
+    end
+
+    test "detects simple cycles" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.process", disabled: false},
+          %{id: "node2", type: "test.process", disabled: false}
+        ],
+        connections: [
+          %{from: %{node: "node1", port: "main"}, to: %{node: "node2", port: "main"}},
+          # Creates cycle
+          %{from: %{node: "node2", port: "main"}, to: %{node: "node1", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_topology(workflow)
+
+      assert {:cycle_detected, path} =
+               Enum.find(errors, fn
+                 {:cycle_detected, _} -> true
+                 _ -> false
+               end)
+
+      # Path should show the cycle
+      assert is_list(path)
+      # At least A -> B -> A
+      assert length(path) >= 3
+    end
+
+    test "detects complex cycles" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "a", type: "test.process", disabled: false},
+          %{id: "b", type: "test.process", disabled: false},
+          %{id: "c", type: "test.process", disabled: false}
+        ],
+        connections: [
+          %{from: %{node: "a", port: "main"}, to: %{node: "b", port: "main"}},
+          %{from: %{node: "b", port: "main"}, to: %{node: "c", port: "main"}},
+          # Creates cycle
+          %{from: %{node: "c", port: "main"}, to: %{node: "a", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_topology(workflow)
+
+      assert {:cycle_detected, _path} =
+               Enum.find(errors, fn
+                 {:cycle_detected, _} -> true
+                 _ -> false
+               end)
+    end
+
+    test "detects orphan nodes" do
+      workflow = %Workflow{
+        nodes: [
+          # Trigger, not orphan
+          %{id: "trigger", type: "test.trigger", disabled: false},
+          # Connected, not orphan
+          %{id: "connected", type: "test.process", disabled: false},
+          # Orphan (not trigger, no connections)
+          %{id: "orphan", type: "test.process", disabled: false}
+        ],
+        connections: [
+          %{from: %{node: "trigger", port: "main"}, to: %{node: "connected", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_topology(workflow)
+      assert {:orphan_node, "orphan"} in errors
+    end
+
+    test "does not flag triggers as orphans" do
+      workflow = %Workflow{
+        nodes: [
+          # Trigger without connections
+          %{id: "trigger", type: "test.trigger", disabled: false}
+        ],
+        connections: []
+      }
+
+      # Should not be flagged as orphan since triggers can exist without connections
+      case Validator.validate_topology(workflow) do
+        {:ok, _} -> :ok
+        {:error, errors} -> refute {:orphan_node, "trigger"} in errors
+      end
+    end
+
+    test "detects multiple inputs to same port" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "src1", type: "test.trigger", disabled: false},
+          %{id: "src2", type: "test.trigger", disabled: false},
+          %{id: "target", type: "test.process", disabled: false}
+        ],
+        connections: [
+          %{from: %{node: "src1", port: "main"}, to: %{node: "target", port: "main"}},
+          # Multiple inputs to same port
+          %{from: %{node: "src2", port: "main"}, to: %{node: "target", port: "main"}}
+        ]
+      }
+
+      assert {:error, errors} = Validator.validate_topology(workflow)
+      assert {:multiple_inputs_to_port, "target", "main"} in errors
+    end
+  end
+
+  describe "detect_cycles/1" do
+    test "returns no cycles for acyclic graph" do
+      workflow = create_workflow_with_connections()
+      assert {:ok, :no_cycles} = Validator.detect_cycles(workflow)
+    end
+
+    test "detects self-loop" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "self", type: "test.process", disabled: false}
+        ],
+        connections: [
+          %{from: %{node: "self", port: "main"}, to: %{node: "self", port: "main"}}
+        ]
+      }
+
+      assert {:error, {:cycle_detected, path}} = Validator.detect_cycles(workflow)
+      assert "self" in path
+    end
+
+    test "ignores disabled nodes in cycle detection" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.process", disabled: false},
+          # Disabled
+          %{id: "node2", type: "test.process", disabled: true}
+        ],
+        connections: [
+          %{from: %{node: "node1", port: "main"}, to: %{node: "node2", port: "main"}},
+          %{from: %{node: "node2", port: "main"}, to: %{node: "node1", port: "main"}}
+        ]
+      }
+
+      # Should not detect cycle because node2 is disabled
+      assert {:ok, :no_cycles} = Validator.detect_cycles(workflow)
+    end
+  end
+
+  describe "validate_execution_readiness/1" do
+    test "validates ready workflow" do
+      workflow = create_workflow_with_connections()
+      assert {:ok, ^workflow} = Validator.validate_execution_readiness(workflow)
+    end
+
+    test "detects missing trigger nodes" do
+      workflow = %Workflow{
+        nodes: [
+          # No triggers
+          %{id: "process", type: "test.process", disabled: false}
+        ],
+        connections: []
+      }
+
+      assert {:error, errors} = Validator.validate_execution_readiness(workflow)
+      assert {:no_trigger_nodes} in errors
+    end
+
+    test "detects unconnected required inputs" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "trigger", type: "test.trigger", disabled: false},
+          # Has required input
+          %{id: "requires_input", type: "test.number_input", disabled: false}
+        ],
+        # No connections
+        connections: []
+      }
+
+      assert {:error, errors} = Validator.validate_execution_readiness(workflow)
+      assert {:required_input_not_connected, "requires_input", "value"} in errors
+    end
+
+    test "allows workflow with trigger nodes" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "trigger", type: "test.trigger", disabled: false}
+        ],
+        connections: []
+      }
+
+      case Validator.validate_execution_readiness(workflow) do
+        {:ok, _} -> :ok
+        {:error, errors} -> refute {:no_trigger_nodes} in errors
+      end
+    end
+  end
+
+  describe "validate_connection/5" do
+    test "validates compatible connection" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "node1", type: "test.trigger"},
+          %{id: "node2", type: "test.process"}
+        ],
+        connections: []
+      }
+
+      assert :ok = Validator.validate_connection(workflow, "node1", "main", "node2", "main")
+    end
+
+    test "returns error for missing nodes" do
+      workflow = %Workflow{nodes: [], connections: []}
+
+      assert {:error, {:connection_missing_from_node, "missing1"}} =
+               Validator.validate_connection(workflow, "missing1", "main", "missing2", "main")
+    end
+
+    test "returns error for incompatible ports" do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "string_out", type: "test.string_output"},
+          %{id: "number_in", type: "test.number_input"}
+        ],
+        connections: []
+      }
+
+      assert {:error, {:incompatible_port_types, _, _, _}} =
+               Validator.validate_connection(workflow, "string_out", "text", "number_in", "value")
+    end
+  end
+
+  describe "validate_and_report/1" do
+    test "returns workflow for valid workflow" do
+      workflow = create_simple_valid_workflow()
+      assert {:ok, ^workflow} = Validator.validate_and_report(workflow)
+    end
+
+    test "returns formatted error report for invalid workflow" do
+      invalid_workflow = %Workflow{
+        nodes: [
+          %{id: "bad", type: "unknown.type", parameters: %{}, disabled: false}
+        ],
+        connections: []
+      }
+
+      assert {:error, report} = Validator.validate_and_report(invalid_workflow)
+      assert is_binary(report)
+      assert String.contains?(report, "validation failed")
+      assert String.contains?(report, "unknown type")
+    end
+  end
+
+  describe "format_validation_errors/1" do
+    test "formats multiple errors with numbering" do
+      errors = [
+        {:unknown_node_type, "node1", "bad.type"},
+        {:missing_required_parameter, "node2", "param1"},
+        {:cycle_detected, ["a", "b", "a"]}
+      ]
+
+      report = Validator.format_validation_errors(errors)
+
+      assert String.contains?(report, "3 error(s)")
+      assert String.contains?(report, "1.")
+      assert String.contains?(report, "2.")
+      assert String.contains?(report, "3.")
+      assert String.contains?(report, "unknown type")
+      assert String.contains?(report, "missing required parameter")
+      assert String.contains?(report, "Cycle detected")
+    end
+
+    test "formats each error type correctly" do
+      errors = [
+        {:unknown_node_type, "node1", "bad.type"},
+        {:missing_required_parameter, "node1", "param1"},
+        {:invalid_parameter_type, "node1", "param1", "string", "number"},
+        {:invalid_parameter_value, "node1", "param1", "out of range"},
+        {:connection_missing_from_node, "missing"},
+        {:connection_missing_to_node, "missing"},
+        {:unknown_output_port, "node1", "bad_port"},
+        {:unknown_input_port, "node1", "bad_port"},
+        {:incompatible_port_types, "node1.out", "node2.in", "type mismatch"},
+        {:cycle_detected, ["a", "b", "a"]},
+        {:orphan_node, "orphan"},
+        {:duplicate_node_id, "dup"},
+        {:duplicate_connection, "a.out", "b.in"},
+        {:empty_workflow},
+        {:no_trigger_nodes},
+        {:multiple_inputs_to_port, "node1", "port1"},
+        {:required_input_not_connected, "node1", "port1"},
+        {:disabled_node_in_critical_path, "node1"}
+      ]
+
+      report = Validator.format_validation_errors(errors)
+
+      # Check that all error types are properly formatted
+      assert String.contains?(report, "unknown type")
+      assert String.contains?(report, "missing required parameter")
+      assert String.contains?(report, "wrong type")
+      assert String.contains?(report, "invalid value")
+      assert String.contains?(report, "non-existent source node")
+      assert String.contains?(report, "non-existent target node")
+      assert String.contains?(report, "does not have output port")
+      assert String.contains?(report, "does not have input port")
+      assert String.contains?(report, "Cannot connect")
+      assert String.contains?(report, "Cycle detected")
+      assert String.contains?(report, "not connected")
+      assert String.contains?(report, "Duplicate")
+      assert String.contains?(report, "no nodes")
+      assert String.contains?(report, "no trigger nodes")
+      assert String.contains?(report, "multiple incoming")
+      assert String.contains?(report, "required input")
+      assert String.contains?(report, "blocking workflow")
+    end
+  end
+
+  # Helper functions
+
+  defp create_simple_valid_workflow do
+    %Workflow{
+      id: "valid_workflow",
+      name: "Valid Workflow",
+      nodes: [
+        %{
+          id: "trigger",
+          type: "test.trigger",
+          parameters: %{},
+          disabled: false,
+          position: [0, 0]
+        },
+        %{
+          id: "process",
+          type: "test.process",
+          parameters: %{},
+          disabled: false,
+          position: [100, 0]
+        }
+      ],
+      connections: [
+        %{
+          from: %{node: "trigger", port: "main"},
+          to: %{node: "process", port: "main"}
+        }
+      ],
+      settings: %{},
+      version: 1
+    }
+  end
+
+  defp create_workflow_with_connections do
+    %Workflow{
+      id: "connected_workflow",
+      name: "Connected Workflow",
+      nodes: [
+        %{
+          id: "trigger",
+          type: "test.trigger",
+          parameters: %{},
+          disabled: false,
+          position: [0, 0]
+        },
+        %{
+          id: "process",
+          type: "test.process",
+          parameters: %{},
+          disabled: false,
+          position: [100, 0]
+        },
+        %{
+          id: "output",
+          type: "test.output",
+          parameters: %{},
+          disabled: false,
+          position: [200, 0]
+        }
+      ],
+      connections: [
+        %{
+          from: %{node: "trigger", port: "main"},
+          to: %{node: "process", port: "main"}
+        },
+        %{
+          from: %{node: "process", port: "main"},
+          to: %{node: "output", port: "main"}
+        }
+      ],
+      settings: %{},
+      version: 1
+    }
+  end
+end
diff --git a/apps/gitlock_workflows/test/gitlock_workflows/runtime/workflow_test.exs b/apps/gitlock_workflows/test/gitlock_workflows/runtime/workflow_test.exs
new file mode 100644
index 0000000..1924c09
--- /dev/null
+++ b/apps/gitlock_workflows/test/gitlock_workflows/runtime/workflow_test.exs
@@ -0,0 +1,427 @@
+defmodule GitlockWorkflows.Runtime.WorkflowTest do
+  use ExUnit.Case, async: true
+
+  alias GitlockWorkflows.Runtime.Workflow
+  alias GitlockWorkflows.Runtime.Registry
+  alias GitlockWorkflows.Fixtures.Nodes.{TriggerNode, ProcessNode, OutputNode}
+
+  setup do
+    # Register test nodes
+    Registry.register_nodes([TriggerNode, ProcessNode, OutputNode])
+
+    on_exit(fn ->
+      Registry.unregister_node("test.trigger")
+      Registry.unregister_node("test.process")
+      Registry.unregister_node("test.output")
+    end)
+
+    :ok
+  end
+
+  describe "from_json/1" do
+    test "parses valid n8n-compatible JSON" do
+      json = ~s({
+        "id": "workflow_123",
+        "name": "Test Workflow",
+        "description": "A test workflow",
+        "nodes": [
+          {
+            "id": "node_1",
+            "type": "test.trigger",
+            "position": [100, 200],
+            "parameters": {},
+            "disabled": false
+          }
+        ],
+        "connections": [],
+        "settings": {"executionOrder": "v1"},
+        "version": 1
+      })
+
+      assert {:ok, workflow} = Workflow.from_json(json)
+      assert workflow.id == "workflow_123"
+      assert workflow.name == "Test Workflow"
+      assert workflow.description == "A test workflow"
+      assert length(workflow.nodes) == 1
+      assert workflow.version == 1
+    end
+
+    test "generates id if missing" do
+      json = ~s({
+        "name": "No ID Workflow",
+        "nodes": [],
+        "connections": []
+      })
+
+      assert {:ok, workflow} = Workflow.from_json(json)
+      assert String.starts_with?(workflow.id, "wf_")
+    end
+
+    test "uses defaults for missing fields" do
+      json = ~s({
+        "nodes": [],
+        "connections": []
+      })
+
+      assert {:ok, workflow} = Workflow.from_json(json)
+      assert workflow.name == "Untitled Workflow"
+      assert is_nil(workflow.description)
+      assert workflow.settings == %{}
+      assert workflow.version == 1
+    end
+
+    test "parses connections correctly" do
+      json = ~s({
+        "name": "Connected Workflow",
+        "nodes": [
+          {"id": "node_1", "type": "test.trigger"},
+          {"id": "node_2", "type": "test.process"}
+        ],
+        "connections": [
+          {
+            "from": {"node": "node_1", "output": "main"},
+            "to": {"node": "node_2", "input": "main"}
+          }
+        ]
+      })
+
+      assert {:ok, workflow} = Workflow.from_json(json)
+      assert length(workflow.connections) == 1
+
+      [conn] = workflow.connections
+      assert conn.from.node == "node_1"
+      assert conn.from.port == "main"
+      assert conn.to.node == "node_2"
+      assert conn.to.port == "main"
+    end
+
+    test "handles invalid JSON" do
+      assert {:error, {:invalid_json, _}} = Workflow.from_json("not json")
+    end
+
+    test "handles parse errors" do
+      # JSON missing required fields in nodes
+      json = ~s({
+        "nodes": [{"position": [0, 0]}],
+        "connections": []
+      })
+
+      assert {:error, {:parse_error, _}} = Workflow.from_json(json)
+    end
+  end
+
+  describe "to_json/1" do
+    test "serializes workflow to JSON" do
+      workflow = %Workflow{
+        id: "wf_123",
+        name: "Test",
+        description: "Test workflow",
+        nodes: [
+          %{
+            id: "node_1",
+            type: "test.trigger",
+            position: [0, 0],
+            parameters: %{},
+            disabled: false
+          }
+        ],
+        connections: [
+          %{
+            from: %{node: "node_1", port: "main"},
+            to: %{node: "node_2", port: "main"}
+          }
+        ],
+        settings: %{},
+        version: 1
+      }
+
+      assert {:ok, json} = Workflow.to_json(workflow)
+      assert {:ok, parsed} = Jason.decode(json)
+
+      assert parsed["id"] == "wf_123"
+      assert parsed["name"] == "Test"
+      assert length(parsed["nodes"]) == 1
+      assert length(parsed["connections"]) == 1
+    end
+  end
+
+  describe "add_node/2" do
+    test "adds node to workflow" do
+      workflow = %Workflow{
+        id: "wf_1",
+        name: "Test",
+        nodes: [],
+        connections: []
+      }
+
+      node = %{
+        id: "node_1",
+        type: "test.trigger",
+        position: [0, 0],
+        parameters: %{},
+        disabled: false
+      }
+
+      updated = Workflow.add_node(workflow, node)
+      assert length(updated.nodes) == 1
+      assert hd(updated.nodes).id == "node_1"
+      # Reactor cleared
+      assert is_nil(updated.reactor)
+    end
+
+    test "raises on missing required fields" do
+      workflow = %Workflow{nodes: [], connections: []}
+
+      assert_raise ArgumentError, ~r/must have id and type/, fn ->
+        Workflow.add_node(workflow, %{position: [0, 0]})
+      end
+    end
+
+    test "raises on duplicate node id" do
+      workflow = %Workflow{
+        nodes: [%{id: "node_1", type: "test.trigger"}],
+        connections: []
+      }
+
+      assert_raise ArgumentError, ~r/already exists/, fn ->
+        Workflow.add_node(workflow, %{id: "node_1", type: "test.process"})
+      end
+    end
+  end
+
+  describe "add_connection/4" do
+    setup do
+      workflow = %Workflow{
+        id: "wf_1",
+        name: "Test",
+        nodes: [
+          %{id: "node_1", type: "test.trigger"},
+          %{id: "node_2", type: "test.process"}
+        ],
+        connections: []
+      }
+
+      {:ok, workflow: workflow}
+    end
+
+    test "adds connection between existing nodes", %{workflow: workflow} do
+      assert {:ok, updated} = Workflow.add_connection(workflow, "node_1", "node_2")
+      assert length(updated.connections) == 1
+
+      [conn] = updated.connections
+      assert conn.from.node == "node_1"
+      # default
+      assert conn.from.port == "main"
+      assert conn.to.node == "node_2"
+      # default
+      assert conn.to.port == "main"
+    end
+
+    test "adds connection with custom ports", %{workflow: workflow} do
+      assert {:ok, updated} =
+               Workflow.add_connection(
+                 workflow,
+                 "node_1",
+                 "node_2",
+                 from_port: "output1",
+                 to_port: "input2"
+               )
+
+      [conn] = updated.connections
+      assert conn.from.port == "output1"
+      assert conn.to.port == "input2"
+    end
+
+    test "returns error for non-existent from node", %{workflow: workflow} do
+      assert {:error, {:node_not_found, "missing"}} =
+               Workflow.add_connection(workflow, "missing", "node_2")
+    end
+
+    test "returns error for non-existent to node", %{workflow: workflow} do
+      assert {:error, {:node_not_found, "missing"}} =
+               Workflow.add_connection(workflow, "node_1", "missing")
+    end
+
+    test "returns error for duplicate connection", %{workflow: workflow} do
+      {:ok, with_connection} = Workflow.add_connection(workflow, "node_1", "node_2")
+
+      assert {:error, :connection_already_exists} =
+               Workflow.add_connection(with_connection, "node_1", "node_2")
+    end
+  end
+
+  describe "get_node/2" do
+    setup do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "n1", type: "test.trigger"},
+          %{id: "n2", type: "test.process"}
+        ],
+        connections: []
+      }
+
+      {:ok, workflow: workflow}
+    end
+
+    test "returns node by id", %{workflow: workflow} do
+      node = Workflow.get_node(workflow, "n1")
+      assert node.id == "n1"
+      assert node.type == "test.trigger"
+    end
+
+    test "returns nil for unknown node", %{workflow: workflow} do
+      assert is_nil(Workflow.get_node(workflow, "unknown"))
+    end
+  end
+
+  describe "get_nodes_by_type/2" do
+    setup do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "n1", type: "test.trigger"},
+          %{id: "n2", type: "test.process"},
+          %{id: "n3", type: "test.trigger"}
+        ],
+        connections: []
+      }
+
+      {:ok, workflow: workflow}
+    end
+
+    test "returns all nodes of type", %{workflow: workflow} do
+      triggers = Workflow.get_nodes_by_type(workflow, "test.trigger")
+      assert length(triggers) == 2
+      assert Enum.all?(triggers, fn n -> n.type == "test.trigger" end)
+    end
+
+    test "returns empty list for unknown type", %{workflow: workflow} do
+      assert Workflow.get_nodes_by_type(workflow, "unknown") == []
+    end
+  end
+
+  describe "get_node_connections/2" do
+    setup do
+      workflow = %Workflow{
+        nodes: [
+          %{id: "n1", type: "test.trigger"},
+          %{id: "n2", type: "test.process"},
+          %{id: "n3", type: "test.output"}
+        ],
+        connections: [
+          %{from: %{node: "n1", port: "main"}, to: %{node: "n2", port: "main"}},
+          %{from: %{node: "n2", port: "main"}, to: %{node: "n3", port: "main"}}
+        ]
+      }
+
+      {:ok, workflow: workflow}
+    end
+
+    test "returns inputs and outputs for node", %{workflow: workflow} do
+      connections = Workflow.get_node_connections(workflow, "n2")
+
+      assert length(connections.inputs) == 1
+      assert length(connections.outputs) == 1
+
+      [input] = connections.inputs
+      assert input.from.node == "n1"
+
+      [output] = connections.outputs
+      assert output.to.node == "n3"
+    end
+
+    test "returns empty lists for unconnected node", %{workflow: workflow} do
+      workflow = %{workflow | connections: []}
+      connections = Workflow.get_node_connections(workflow, "n2")
+
+      assert connections.inputs == []
+      assert connections.outputs == []
+    end
+  end
+
+  describe "reactor_ready?/1" do
+    test "returns false when reactor is nil" do
+      workflow = %Workflow{reactor: nil}
+      refute Workflow.reactor_ready?(workflow)
+    end
+
+    test "returns true when reactor exists" do
+      # Mock reactor
+      workflow = %Workflow{reactor: %{}}
+      assert Workflow.reactor_ready?(workflow)
+    end
+  end
+
+  describe "to_reactor/1" do
+    test "returns error for empty workflow" do
+      workflow = %Workflow{nodes: [], connections: []}
+      assert {:error, :empty_workflow} = Workflow.to_reactor(workflow)
+    end
+
+    test "successfully converts workflow with registered trigger node to reactor" do
+      workflow = %Workflow{
+        id: "wf_1",
+        nodes: [
+          %{id: "n1", type: "test.trigger", parameters: %{}, disabled: false}
+        ],
+        connections: []
+      }
+
+      assert {:ok, %Workflow{reactor: reactor}} = Workflow.to_reactor(workflow)
+
+      # Verify the reactor was properly built
+      assert reactor != nil
+      assert reactor.steps != []
+      assert length(reactor.steps) == 1
+
+      # Verify the step configuration
+      step = hd(reactor.steps)
+      assert step.impl == GitlockWorkflows.Fixtures.Nodes.TriggerNode
+      assert step.name == :n1
+    end
+
+    test "successfully converts workflow with bridged node to reactor" do
+      # Create a test node using the bridged interface
+      defmodule TestBridgedNode do
+        use GitlockWorkflows.Runtime.Node
+
+        @impl true
+        def metadata do
+          %{
+            id: "test.bridged",
+            displayName: "Test Bridged Node",
+            group: "test",
+            version: 1,
+            description: "Test node with proper bridging",
+            inputs: [],
+            outputs: [%{name: "main", type: :any, required: false}],
+            parameters: []
+          }
+        end
+
+        @impl true
+        def execute(_input_data, _parameters, _context) do
+          {:ok, %{"main" => "test success"}}
+        end
+
+        @impl true
+        def validate_parameters(_parameters) do
+          :ok
+        end
+      end
+
+      # Register the node
+      :ok = GitlockWorkflows.Runtime.Registry.register_node(TestBridgedNode)
+
+      workflow = %Workflow{
+        id: "test_workflow",
+        nodes: [
+          %{id: "n1", type: "test.bridged", parameters: %{}, disabled: false}
+        ],
+        connections: []
+      }
+
+      assert {:ok, %Workflow{reactor: reactor}} = Workflow.to_reactor(workflow)
+      assert reactor != nil
+    end
+  end
+end
diff --git a/apps/gitlock_workflows/test/support/fixtures/nodes.ex b/apps/gitlock_workflows/test/support/fixtures/nodes.ex
new file mode 100644
index 0000000..ee2d88e
--- /dev/null
+++ b/apps/gitlock_workflows/test/support/fixtures/nodes.ex
@@ -0,0 +1,428 @@
+defmodule GitlockWorkflows.Fixtures.Nodes do
+  @moduledoc """
+  Collection of test node implementations.
+  """
+
+  defmodule ValidNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.valid",
+        displayName: "Valid Test Node",
+        group: "test",
+        version: 1,
+        description: "A valid test node",
+        inputs: [%{name: "input", type: :any, required: true}],
+        outputs: [%{name: "output", type: :any}],
+        parameters: [],
+        tags: ["test", "valid"],
+        deprecated: false,
+        experimental: true
+      }
+    end
+
+    @impl true
+    def execute(input, _params, _context) do
+      {:ok, %{:output => input["input"]}}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule MinimalNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.minimal",
+        displayName: "Minimal Node",
+        group: "test",
+        version: 1,
+        description: "Minimal metadata",
+        inputs: [],
+        outputs: [],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(_input, _params, _context) do
+      {:ok, %{}}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule SimpleNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.simple",
+        displayName: "Simple Node",
+        group: "test",
+        version: 1,
+        description: "A simple test node",
+        inputs: [%{name: "value", type: :number, required: true}],
+        outputs: [%{name: "result", type: :number}],
+        parameters: [
+          %{name: "multiplier", type: "number", default: 2, required: false}
+        ]
+      }
+    end
+
+    @impl true
+    def execute(input, params, _context) do
+      value = Map.get(input, "value", 0)
+      multiplier = Map.get(params, "multiplier", 2)
+      {:ok, %{:result => value * multiplier}}
+    end
+
+    @impl true
+    def validate_parameters(params) do
+      case Map.get(params, "multiplier") do
+        nil -> :ok
+        val when is_number(val) -> :ok
+        _ -> {:error, [{:invalid_type, "multiplier", "Expected number"}]}
+      end
+    end
+  end
+
+  defmodule EchoNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.echo",
+        displayName: "Echo Node",
+        group: "test",
+        version: 1,
+        description: "Echoes input to output",
+        inputs: [%{name: "input", type: :any, required: true}],
+        outputs: [%{name: "output", type: :any}],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(input_data, _params, _context) do
+      {:ok, %{:output => input_data["input"]}}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule ErrorNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.error",
+        displayName: "Error Node",
+        group: "test",
+        version: 1,
+        description: "A node that always fails",
+        inputs: [%{name: "main", type: :any, required: false}],
+        outputs: [],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(_input, _params, _context) do
+      {:error, "Intentional error"}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule SlowNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.slow",
+        displayName: "Slow Node",
+        group: "test",
+        version: 1,
+        description: "A node that takes time",
+        inputs: [],
+        outputs: [],
+        parameters: [%{name: "delay_ms", type: "number", default: 100}]
+      }
+    end
+
+    @impl true
+    def execute(_input, params, _context) do
+      delay = Map.get(params, "delay_ms", 100)
+      :timer.sleep(delay)
+      {:ok, %{:completed => true}}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule CrashNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.crash",
+        displayName: "Crash Node",
+        group: "test",
+        version: 1,
+        description: "A node that crashes",
+        inputs: [],
+        outputs: [],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(_input, _params, _context) do
+      raise "Intentional crash!"
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule TriggerNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.trigger",
+        displayName: "Test Trigger",
+        group: "trigger",
+        version: 1,
+        description: "Test trigger node",
+        inputs: [],
+        outputs: [%{name: "main", type: :any}],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(_input, _params, _context) do
+      {:ok, %{:main => %{triggered_at: DateTime.utc_now()}}}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule ProcessNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.process",
+        displayName: "Test Process",
+        group: "transform",
+        version: 1,
+        description: "Test processor node",
+        inputs: [%{name: "main", type: :any, required: true}],
+        outputs: [%{name: "main", type: :any}],
+        parameters: [
+          %{name: "delay_ms", type: "number", default: 0}
+        ]
+      }
+    end
+
+    @impl true
+    def execute(input, params, _context) do
+      delay = Map.get(params, "delay_ms", 0)
+      if delay > 0, do: :timer.sleep(delay)
+
+      {:ok, %{:main => Map.put(input["main"] || %{}, :processed, true)}}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule OutputNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.output",
+        displayName: "Test Output",
+        group: "output",
+        version: 1,
+        description: "Test output node",
+        inputs: [%{name: "main", type: :any, required: true}],
+        outputs: [],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(_input, _params, _context) do
+      {:ok, %{}}
+    end
+
+    @impl true
+    def validate_parameters(_params), do: :ok
+  end
+
+  defmodule AnalysisNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.analysis",
+        displayName: "Analysis Node",
+        group: "analysis",
+        version: 1,
+        description: "Test analysis node",
+        inputs: [],
+        outputs: [],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(_, _, _), do: {:ok, %{}}
+
+    @impl true
+    def validate_parameters(_), do: :ok
+  end
+
+  defmodule SearchableNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.searchable",
+        displayName: "Hotspot Analyzer",
+        group: "analysis",
+        version: 1,
+        description: "Analyzes code hotspots",
+        inputs: [],
+        outputs: [],
+        parameters: [],
+        tags: ["git", "analysis", "hotspot"]
+      }
+    end
+
+    @impl true
+    def execute(_, _, _), do: {:ok, %{}}
+
+    @impl true
+    def validate_parameters(_), do: :ok
+  end
+
+  defmodule TestNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.node",
+        displayName: "Test Node",
+        group: "test",
+        version: 1,
+        description: "A test node",
+        inputs: [
+          %{name: "main", type: :any, required: true},
+          %{name: "optional", type: :string, required: false}
+        ],
+        outputs: [
+          %{name: "main", type: :any},
+          %{name: "secondary", type: :number}
+        ],
+        parameters: [
+          %{
+            name: "threshold",
+            displayName: "Threshold",
+            type: "number",
+            default: 10,
+            required: false
+          }
+        ]
+      }
+    end
+
+    @impl true
+    def execute(input_data, parameters, _context) do
+      threshold = Map.get(parameters, "threshold", 10)
+      result = Map.get(input_data, "main", 0) + threshold
+
+      {:ok, %{:main => result, :secondary => threshold}}
+    end
+
+    @impl true
+    def validate_parameters(parameters) do
+      case Map.get(parameters, "threshold") do
+        nil -> :ok
+        val when is_number(val) -> :ok
+        _ -> {:error, [{:invalid_type, "threshold must be a number"}]}
+      end
+    end
+  end
+
+  defmodule TargetNode do
+    @moduledoc false
+    use GitlockWorkflows.Runtime.Node
+
+    @impl true
+    def metadata do
+      %{
+        id: "test.target",
+        displayName: "Target Node",
+        group: "test",
+        version: 1,
+        description: "A target test node",
+        inputs: [
+          %{name: "main", type: :any, required: true},
+          %{name: "numbers", type: :number, required: false}
+        ],
+        outputs: [
+          %{name: "result", type: :string}
+        ],
+        parameters: []
+      }
+    end
+
+    @impl true
+    def execute(_input_data, _parameters, _context) do
+      {:ok, %{:result => "processed"}}
+    end
+
+    @impl true
+    def validate_parameters(_parameters), do: :ok
+  end
+end
diff --git a/apps/gitlock_workflows/test/test_helper.exs b/apps/gitlock_workflows/test/test_helper.exs
new file mode 100644
index 0000000..869559e
--- /dev/null
+++ b/apps/gitlock_workflows/test/test_helper.exs
@@ -0,0 +1 @@
+ExUnit.start()
diff --git a/config/dev.exs b/config/dev.exs
index fcf40a7..c48d5dd 100644
--- a/config/dev.exs
+++ b/config/dev.exs
@@ -25,7 +25,7 @@ config :gitlock_phx, GitlockPhxWeb.Endpoint,
   debug_errors: true,
   secret_key_base: "K966iHPm7n+pF66q4rDM/m6R284ZJ3k3WxX5lHqOjk45AGU23pwvMkZvgC1w6UL4",
   watchers: [
-    esbuild: {Esbuild, :install_and_run, [:gitlock_phx, ~w(--sourcemap=inline --watch)]},
+    node: ["build.mjs", "--watch", cd: Path.expand("../apps/gitlock_phx/assets", __DIR__)],
     tailwind: {Tailwind, :install_and_run, [:gitlock_phx, ~w(--watch)]}
   ]
 
@@ -59,7 +59,8 @@ config :gitlock_phx, GitlockPhxWeb.Endpoint,
     patterns: [
       ~r"priv/static/(?!uploads/).*(js|css|png|jpeg|jpg|gif|svg)$",
       ~r"priv/gettext/.*(po)$",
-      ~r"lib/gitlock_phx_web/(?:controllers|live|components|router)/?.*\.(ex|heex)$"
+      ~r"lib/gitlock_phx_web/(?:controllers|live|components|router)/?.*\.(ex|heex)$",
+      ~r"assets/svelte/.*\.svelte$"
     ]
   ]
 
diff --git a/fly.toml b/fly.toml
index 1d7893d..722ab14 100644
--- a/fly.toml
+++ b/fly.toml
@@ -4,7 +4,7 @@
 #
 
 app = 'gitlock'
-primary_region = 'bos'
+primary_region = 'ewr'
 
 [build]
   dockerfile = 'Dockerfile'
diff --git a/mix.lock b/mix.lock
index 3ba38c4..96800c5 100644
--- a/mix.lock
+++ b/mix.lock
@@ -21,7 +21,9 @@
   "gettext": {:hex, :gettext, "0.26.2", "5978aa7b21fada6deabf1f6341ddba50bc69c999e812211903b169799208f2a8", [:mix], [{:expo, "~> 0.5.1 or ~> 1.0", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "aa978504bcf76511efdc22d580ba08e2279caab1066b76bb9aa81c4a1e0a32a5"},
   "heroicons": {:git, "https://github.com/tailwindlabs/heroicons.git", "88ab3a0d790e6a47404cba02800a6b25d2afae50", [tag: "v2.1.1", sparse: "optimized", depth: 1]},
   "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"},
+  "iterex": {:hex, :iterex, "0.1.2", "58f9b9b9a22a55cbfc7b5234a9c9c63eaac26d276b3db80936c0e1c60355a5a6", [:mix], [], "hexpm", "2e103b8bcc81757a9af121f6dc0df312c9a17220f302b1193ef720460d03029d"},
   "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"},
+  "libgraph": {:hex, :libgraph, "0.16.0", "3936f3eca6ef826e08880230f806bfea13193e49bf153f93edcf0239d4fd1d07", [:mix], [], "hexpm", "41ca92240e8a4138c30a7e06466acc709b0cbb795c643e9e17174a178982d6bf"},
   "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"},
   "mint": {:hex, :mint, "1.7.1", "113fdb2b2f3b59e47c7955971854641c61f378549d73e829e1768de90fc1abf1", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "fceba0a4d0f24301ddee3024ae116df1c3f4bb7a563a731f45fdfeb9d39a231b"},
   "mox": {:hex, :mox, "1.2.0", "a2cd96b4b80a3883e3100a221e8adc1b98e4c3a332a8fc434c39526babafd5b3", [:mix], [{:nimble_ownership, "~> 1.0", [hex: :nimble_ownership, repo: "hexpm", optional: false]}], "hexpm", "c7b92b3cc69ee24a7eeeaf944cd7be22013c52fcb580c1f33f50845ec821089a"},
@@ -39,7 +41,10 @@
   "plug": {:hex, :plug, "1.18.0", "d78df36c41f7e798f2edf1f33e1727eae438e9dd5d809a9997c463a108244042", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "819f9e176d51e44dc38132e132fe0accaf6767eab7f0303431e404da8476cfa2"},
   "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"},
   "postgrex": {:hex, :postgrex, "0.20.0", "363ed03ab4757f6bc47942eff7720640795eb557e1935951c1626f0d303a3aed", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "d36ef8b36f323d29505314f704e21a1a038e2dc387c6409ee0cd24144e187c0f"},
+  "reactor": {:hex, :reactor, "0.15.6", "d717f9add549b25a089a94c90197718d2d838e35d81dd776b1d81587d4cf2aaa", [:mix], [{:igniter, "~> 0.4", [hex: :igniter, repo: "hexpm", optional: true]}, {:iterex, "~> 0.1", [hex: :iterex, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:libgraph, "~> 0.16", [hex: :libgraph, repo: "hexpm", optional: false]}, {:spark, "~> 2.0", [hex: :spark, repo: "hexpm", optional: false]}, {:splode, "~> 0.2", [hex: :splode, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.2", [hex: :telemetry, repo: "hexpm", optional: false]}, {:yaml_elixir, "~> 2.11", [hex: :yaml_elixir, repo: "hexpm", optional: false]}, {:ymlr, "~> 5.0", [hex: :ymlr, repo: "hexpm", optional: false]}], "hexpm", "74db98165e3644d86e0f723672d91ceca4339eaa935bcad7e78bf146a46d77b9"},
   "req": {:hex, :req, "0.5.12", "7ce85835867a114c28b6cfc2d8a412f86660290907315ceb173a00e587b853d2", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "d65f3d0e7032eb245706554cb5240dbe7a07493154e2dd34e7bb65001aa6ef32"},
+  "spark": {:hex, :spark, "2.4.1", "d6807291e74b51f6efb6dd4e0d58216ae3729d45c35c456e049556e7e946e364", [:mix], [{:igniter, ">= 0.3.64 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}, {:sourceror, "~> 1.2", [hex: :sourceror, repo: "hexpm", optional: true]}], "hexpm", "8b065733de9840cac584515f82182ac5ba66a973a47bc5036348dc740662b46b"},
+  "splode": {:hex, :splode, "0.3.0", "ff8effecc509a51245df2f864ec78d849248647c37a75886033e3b1a53ca9470", [:mix], [], "hexpm", "73cfd0892d7316d6f2c93e6e8784bd6e137b2aa38443de52fd0a25171d106d81"},
   "stream_data": {:hex, :stream_data, "1.2.0", "58dd3f9e88afe27dc38bef26fce0c84a9e7a96772b2925c7b32cd2435697a52b", [:mix], [], "hexpm", "eb5c546ee3466920314643edf68943a5b14b32d1da9fe01698dc92b73f89a9ed"},
   "swoosh": {:hex, :swoosh, "1.19.3", "02ad4455939f502386e4e1443d4de94c514995fd0e51b3cafffd6bd270ffe81c", [:mix], [{:bandit, ">= 1.0.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mua, "~> 0.2.3", [hex: :mua, repo: "hexpm", optional: true]}, {:multipart, "~> 0.4", [hex: :multipart, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:req, "~> 0.5.10 or ~> 0.6 or ~> 1.0", [hex: :req, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "04a10f8496786b744b84130e3510eb53ca51e769c39511b65023bdf4136b732f"},
   "tailwind": {:hex, :tailwind, "0.3.1", "a89d2835c580748c7a975ad7dd3f2ea5e63216dc16d44f9df492fbd12c094bed", [:mix], [], "hexpm", "98a45febdf4a87bc26682e1171acdedd6317d0919953c353fcd1b4f9f4b676a2"},
@@ -50,4 +55,7 @@
   "tidewave": {:hex, :tidewave, "0.1.10", "8cb6d25d7788b67b72aa0918219bfce956d5d37f02c6ce27602d38f88054979f", [:mix], [{:circular_buffer, "~> 0.4", [hex: :circular_buffer, repo: "hexpm", optional: false]}, {:igniter, ">= 0.5.47 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:plug, "~> 1.17", [hex: :plug, repo: "hexpm", optional: false]}, {:req, "~> 0.5", [hex: :req, repo: "hexpm", optional: false]}], "hexpm", "a2f589f56b06c66354930ba74f3411635526c60c352dd88f6123415aed000525"},
   "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
   "websock_adapter": {:hex, :websock_adapter, "0.5.8", "3b97dc94e407e2d1fc666b2fb9acf6be81a1798a2602294aac000260a7c4a47d", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "315b9a1865552212b5f35140ad194e67ce31af45bcee443d4ecb96b5fd3f3782"},
+  "yamerl": {:hex, :yamerl, "0.10.0", "4ff81fee2f1f6a46f1700c0d880b24d193ddb74bd14ef42cb0bcf46e81ef2f8e", [:rebar3], [], "hexpm", "346adb2963f1051dc837a2364e4acf6eb7d80097c0f53cbdc3046ec8ec4b4e6e"},
+  "yaml_elixir": {:hex, :yaml_elixir, "2.12.1", "d74f2d82294651b58dac849c45a82aaea639766797359baff834b64439f6b3f4", [:mix], [{:yamerl, "~> 0.10", [hex: :yamerl, repo: "hexpm", optional: false]}], "hexpm", "d9ac16563c737d55f9bfeed7627489156b91268a3a21cd55c54eb2e335207fed"},
+  "ymlr": {:hex, :ymlr, "5.1.4", "b924d61e1fc1ec371cde6ab3ccd9311110b1e052fc5c2460fb322e8380e7712a", [:mix], [], "hexpm", "75f16cf0709fbd911b30311a0359a7aa4b5476346c01882addefd5f2b1cfaa51"},
 }