public class Workflow
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public string Icon { get; set; }
    public List<WorkflowNodeDefinition> Nodes { get; set; }
    public Dictionary<string, string> Connections { get; set; } // NodeId -> NextNodeId
    public string EntryNodeId { get; set; }
    public WorkflowMetadata Metadata { get; set; }
}

public class WorkflowNodeDefinition
{
    public string Id { get; set; }
    public string NodeType { get; set; } // Type name for instantiation
    public Dictionary<string, object> Configuration { get; set; }
    public bool AllowBackNavigation { get; set; } = true;
    public string? CustomBackNodeId { get; set; }
}

public class WorkflowMetadata
{
    public string Author { get; set; }
    public Version Version { get; set; }
    public string[] Tags { get; set; }
    public string[] RequiredServices { get; set; }
}

public interface IWorkflowNode
{
    string Id { get; }
    string Name { get; }
    Task<WorkflowResult> ExecuteAsync(WorkflowContext context);
}

public enum NodeUIType
{
    ItemList,          // Show list of items (prompts, actions, etc.)
    TextInput,         // Show text input box
    TextDisplay,       // Show TextDisplayPanel
    MultiStepInput,    // Multiple input fields
    Confirmation,      // Yes/No dialog
    Custom             // Custom UI component
}

public interface INodeUIProvider
{
    NodeUIType UIType { get; }
    string HintText { get; }
    bool ReadOnly { get; }
    IEnumerable<object> GetItems(WorkflowContext context);
    string GetDisplayText(object item);
    string GetSecondaryText(object item);
    string GetIcon(object item);
    Color? GetItemColor(object item);
}

public class WorkflowContext
{
    public Dictionary<string, object> Data { get; }
    public CancellationToken CancellationToken { get; }
    public IServiceProvider Services { get; }
    
    public T Get<T>(string key);
    public T GetOrDefault<T>(string key, T defaultValue);
    public void Set<T>(string key, T value);
    public bool Has(string key);
    public void Remove(string key);
    public WorkflowContext Clone(); // For navigation history
}

public class WorkflowResult
{
    public bool Success { get; set; }
    public WorkflowContext Context { get; set; }
    public string? NextNodeId { get; set; } // For branching
    public object? Output { get; set; }
    public string? ErrorMessage { get; set; }
    
    public static WorkflowResult Success(WorkflowContext context, string? nextNodeId = null, object? output = null);
    public static WorkflowResult Error(WorkflowContext context, string errorMessage);
}

public class WorkflowEngine
{
    private readonly IWorkflowRegistry _registry;
    private readonly IServiceProvider _services;
    private readonly WorkflowNavigationStack _navigationStack;
    
    public event EventHandler<NodeExecutedEventArgs>? NodeExecuted;
    public event EventHandler<NodeErrorEventArgs>? NodeError;
    
    public async Task<WorkflowResult> StartWorkflowAsync(string workflowId, WorkflowContext initialContext);
    public async Task<WorkflowResult> ExecuteNodeAsync(IWorkflowNode node, WorkflowContext context);
    public async Task<WorkflowResult> MoveToNextNodeAsync(string nodeId, WorkflowContext context);
    public NavigationFrame? NavigateBack();
    public void Reset();
}

public class WorkflowNavigationStack
{
    private readonly Stack<NavigationFrame> _history;
    
    public void Push(string nodeId, WorkflowContext context);
    public NavigationFrame? Pop();
    public void Clear();
    public int Count { get; }
}

public class NavigationFrame
{
    public string NodeId { get; set; }
    public WorkflowContext Context { get; set; }
    public DateTime Timestamp { get; set; }
}

public interface IWorkflowRegistry
{
    void RegisterWorkflow(Workflow workflow);
    void RegisterNode(string nodeType, Type nodeClass);
    void RegisterPlugin(IWorkflowPlugin plugin);
    
    Workflow GetWorkflow(string workflowId);
    IEnumerable<Workflow> GetAllWorkflows();
    IWorkflowNode CreateNode(string nodeType, Dictionary<string, object>? config = null);
}

public interface IWorkflowPlugin
{
    string PluginId { get; }
    string Name { get; }
    Version Version { get; }
    IEnumerable<Workflow> GetWorkflows();
    IEnumerable<(string NodeType, Type NodeClass)> GetNodes();
}

public partial class CommandPaletteForm : BorderlessFormBase
{
    private WorkflowEngine _engine;
    private IWorkflowRegistry _registry;
    private Workflow? _currentWorkflow;
    private IWorkflowNode? _currentNode;
    private WorkflowContext _context;
    
    // UI Components (unchanged)
    private TextBox _searchBox;
    private ListBox _resultsList;
    private Label _hintLabel;
    private TextDisplayPanel _textDisplayPanel;
    
    public void ShowPalette()
    {
        var workflows = _registry.GetAllWorkflows();
        if (workflows.Count() == 1)
        {
            StartWorkflow(workflows.First().Id);
        }
        else
        {
            ShowWorkflowSelection(workflows);
        }
    }
    
    private async void StartWorkflow(string workflowId)
    {
        _currentWorkflow = _registry.GetWorkflow(workflowId);
        _context = new WorkflowContext(_services);
        _currentNode = _registry.CreateNode(_currentWorkflow.EntryNodeId);
        await ExecuteCurrentNode();
    }
    
    private async Task ExecuteCurrentNode()
    {
        if (_currentNode is INodeUIProvider uiProvider)
        {
            RenderNodeUI(uiProvider);
        }
        
        // UI now waits for user input via events (Enter, selection, etc.)
    }
    
    private void RenderNodeUI(INodeUIProvider uiProvider)
    {
        _hintLabel.Text = uiProvider.HintText;
        _searchBox.ReadOnly = uiProvider.ReadOnly;
        
        switch (uiProvider.UIType)
        {
            case NodeUIType.ItemList:
                RenderItemList(uiProvider);
                break;
            case NodeUIType.TextInput:
                RenderTextInput(uiProvider);
                break;
            case NodeUIType.TextDisplay:
                RenderTextDisplay(uiProvider);
                break;
            // ... other UI types
        }
    }
    
    private async void HandleEnter()
    {
        BuildContextFromUI(); // Populate context with current UI state
        var result = await _engine.ExecuteNodeAsync(_currentNode, _context);
        
        if (result.Success && result.NextNodeId != null)
        {
            _currentNode = _registry.CreateNode(result.NextNodeId);
            _context = result.Context;
            await ExecuteCurrentNode();
        }
        else if (!result.Success)
        {
            ShowError(result.ErrorMessage);
        }
        else
        {
            // Workflow complete
            ResetState();
        }
    }
    
    private void HandleEscape()
    {
        var previousFrame = _engine.NavigateBack();
        if (previousFrame != null)
        {
            _currentNode = _registry.CreateNode(previousFrame.NodeId);
            _context = previousFrame.Context;
            ExecuteCurrentNode();
        }
        else
        {
            Hide();
        }
    }
}

var fillPlaceholdersWorkflow = new Workflow
{
    Id = "fill-placeholders",
    Name = "Fill Placeholders and Execute",
    Description = "Fill template variables and execute prompt",
    Icon = "📝",
    Nodes = new List<WorkflowNodeDefinition>
    {
        new() { Id = "search-prompts", NodeType = "SearchPromptsNode" },
        new() { Id = "show-actions", NodeType = "ShowActionsNode" },
        new() { Id = "check-placeholders", NodeType = "ConditionalNode", 
                Configuration = new() { ["condition"] = "hasPlaceholders" } },
        new() { Id = "fill-loop", NodeType = "LoopNode",
                Configuration = new() { ["itemsKey"] = "placeholders" } },
        new() { Id = "fill-placeholder", NodeType = "FillPlaceholderNode" },
        new() { Id = "apply-values", NodeType = "ApplyPlaceholdersNode" },
        new() { Id = "show-output-options", NodeType = "ShowActionsNode" },
        new() { Id = "execute-llm", NodeType = "ExecuteLLMNode" },
        new() { Id = "copy", NodeType = "CopyToClipboardNode" },
        new() { Id = "paste", NodeType = "PasteNode" },
        new() { Id = "close", NodeType = "CloseCommandPaletteNode" }
    },
    Connections = new Dictionary<string, string>
    {
        ["search-prompts"] = "show-actions",
        ["show-actions"] = "check-placeholders",
        ["check-placeholders"] = "fill-loop", // if true
        ["fill-loop"] = "fill-placeholder",
        ["fill-placeholder"] = "fill-loop", // loop back
        ["fill-loop-exit"] = "apply-values", // when loop completes
        ["apply-values"] = "show-output-options",
        ["show-output-options"] = "execute-llm", // if execute selected
        ["execute-llm"] = "copy", // or "paste"
        ["copy"] = "close",
        ["paste"] = "close"
    },
    EntryNodeId = "search-prompts"
};

public class BuiltInWorkflowsPlugin : IWorkflowPlugin
{
    public string PluginId => "promptarq.builtin";
    public string Name => "PromptArq Built-in Workflows";
    public Version Version => new Version(1, 0, 0);
    
    public IEnumerable<Workflow> GetWorkflows()
    {
        yield return CreateFillPlaceholdersWorkflow();
        yield return CreateOneTimePromptWorkflow();
        yield return CreateQuickPasteWorkflow();
        // ... more workflows
    }
    
    public IEnumerable<(string, Type)> GetNodes()
    {
        yield return ("SearchPromptsNode", typeof(SearchPromptsNode));
        yield return ("ShowActionsNode", typeof(ShowActionsNode));
        yield return ("FillPlaceholderNode", typeof(FillPlaceholderNode));
        yield return ("ExecuteLLMNode", typeof(ExecuteLLMNode));
        yield return ("CopyToClipboardNode", typeof(CopyToClipboardNode));
        yield return ("PasteNode", typeof(PasteNode));
        yield return ("ShowTextPanelNode", typeof(ShowTextPanelNode));
        // ... more nodes
    }
}

// Third-party plugin example
public class CalculatorPlugin : IWorkflowPlugin
{
    public string PluginId => "community.calculator";
    public string Name => "Calculator Workflow";
    public Version Version => new Version(1, 0, 0);
    
    public IEnumerable<Workflow> GetWorkflows()
    {
        yield return new Workflow
        {
            Id = "calculator",
            Name = "Calculator",
            Description = "Perform mathematical calculations",
            Icon = "🔢",
            Nodes = new List<WorkflowNodeDefinition>
            {
                new() { Id = "input", NodeType = "TextInputNode",
                        Configuration = new() { ["hint"] = "Enter calculation (e.g., 5 + 3 * 2)" } },
                new() { Id = "calculate", NodeType = "CalculateNode" },
                new() { Id = "show-result", NodeType = "ShowTextPanelNode" },
                new() { Id = "copy", NodeType = "CopyToClipboardNode" },
                new() { Id = "close", NodeType = "CloseCommandPaletteNode" }
            },
            Connections = new Dictionary<string, string>
            {
                ["input"] = "calculate",
                ["calculate"] = "show-result",
                ["show-result"] = "copy",
                ["copy"] = "close"
            },
            EntryNodeId = "input"
        };
    }
    
    public IEnumerable<(string, Type)> GetNodes()
    {
        yield return ("CalculateNode", typeof(CalculateNode));
    }
}