@poolzin/pool-bot 2026.3.7 → 2026.3.9

package/docs/integrations/XYOPS_PLAN.md

@@ -0,0 +1,978 @@
+# xyOps Integration - Implementation Plan
+
+**Status**: Ready for implementation  
+**Priority**: High  
+**Estimated Duration**: 3 weeks  
+**Dependencies**: None (Node.js based)
+
+---
+
+## Overview
+
+Integrate xyOps as both a Plugin Extension and Gateway Node to enable workflow automation, job scheduling, and infrastructure monitoring within PoolBot.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     PoolBot Core                            │
+├─────────────────────────────────────────────────────────────┤
+│  Plugin Layer (Deep Integration)                            │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
+│  │   Workflow   │  │   Schedule   │  │   Monitor    │       │
+│  │   Engine     │  │   Engine     │  │   Engine     │       │
+│  └──────────────┘  └──────────────┘  └──────────────┘       │
+├─────────────────────────────────────────────────────────────┤
+│  Gateway Node Layer (External Process Support)              │
+│  ┌─────────────────────────────────────────────────────┐    │
+│  │              xyOps Gateway Node                       │    │
+│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────┐   │    │
+│  │  │  Node Client │  │  xyOps Core  │  │  Visual  │   │    │
+│  │  │  (WebSocket) │──│              │──│  Editor  │   │    │
+│  │  └──────────────┘  └──────────────┘  └──────────┘   │    │
+│  └─────────────────────────────────────────────────────┘    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Integration Modes
+
+| Mode | Use Case | Implementation |
+|------|----------|----------------|
+| **Plugin** | Single-instance, deep integration | Direct PoolBot extension |
+| **Gateway Node** | Multi-instance, distributed | External process via WebSocket |
+| **Hybrid** | Best of both | Plugin + optional external nodes |
+
+## Implementation Steps
+
+### Week 1: Plugin Foundation
+
+#### Day 1-2: Plugin Structure
+```typescript
+// extensions/xyops/src/plugin.ts
+import { PoolBotPlugin, PluginContext } from '@poolbot/plugin-sdk';
+import { WorkflowEngine } from './workflow/engine';
+import { ScheduleEngine } from './schedule/engine';
+import { MonitorEngine } from './monitor/engine';
+
+export default class XyOpsPlugin implements PoolBotPlugin {
+  name = 'xyops';
+  version = '1.0.0';
+  
+  private workflowEngine: WorkflowEngine;
+  private scheduleEngine: ScheduleEngine;
+  private monitorEngine: MonitorEngine;
+  
+  async onLoad(context: PluginContext) {
+    // Initialize engines
+    this.workflowEngine = new WorkflowEngine(context);
+    this.scheduleEngine = new ScheduleEngine(context);
+    this.monitorEngine = new MonitorEngine(context);
+    
+    // Register CLI commands
+    context.registerCommand({
+      name: 'workflow',
+      description: 'Manage workflows',
+      subcommands: [
+        { name: 'create', handler: this.handleWorkflowCreate },
+        { name: 'list', handler: this.handleWorkflowList },
+        { name: 'run', handler: this.handleWorkflowRun },
+        { name: 'delete', handler: this.handleWorkflowDelete }
+      ]
+    });
+    
+    context.registerCommand({
+      name: 'schedule',
+      description: 'Manage scheduled jobs',
+      subcommands: [
+        { name: 'add', handler: this.handleScheduleAdd },
+        { name: 'list', handler: this.handleScheduleList },
+        { name: 'remove', handler: this.handleScheduleRemove }
+      ]
+    });
+    
+    // Register skills
+    context.registerSkill({
+      name: 'workflow.create',
+      description: 'Create a new workflow',
+      parameters: z.object({
+        name: z.string(),
+        steps: z.array(z.object({
+          name: z.string(),
+          type: z.enum(['agent', 'tool', 'condition', 'loop']),
+          config: z.record(z.any())
+        }))
+      }),
+      handler: this.workflowEngine.create.bind(this.workflowEngine)
+    });
+    
+    context.registerSkill({
+      name: 'schedule.cron',
+      description: 'Schedule a workflow with cron expression',
+      parameters: z.object({
+        workflowId: z.string(),
+        cron: z.string(),
+        enabled: z.boolean().optional()
+      }),
+      handler: this.scheduleEngine.schedule.bind(this.scheduleEngine)
+    });
+    
+    context.registerSkill({
+      name: 'monitor.check',
+      description: 'Set up monitoring for a target',
+      parameters: z.object({
+        target: z.string(),
+        type: z.enum(['http', 'tcp', 'dns']),
+        interval: z.number(),
+        alerts: z.array(z.object({
+          condition: z.string(),
+          action: z.enum(['notify', 'webhook', 'workflow'])
+        }))
+      }),
+      handler: this.monitorEngine.addCheck.bind(this.monitorEngine)
+    });
+  }
+  
+  async onReady() {
+    // Start scheduled jobs
+    await this.scheduleEngine.start();
+    
+    // Start monitoring
+    await this.monitorEngine.start();
+  }
+  
+  async onUnload() {
+    // Cleanup
+    await this.scheduleEngine.stop();
+    await this.monitorEngine.stop();
+  }
+}
+```
+
+#### Day 3-4: Workflow Engine
+```typescript
+// extensions/xyops/src/workflow/engine.ts
+export interface Workflow {
+  id: string;
+  name: string;
+  description?: string;
+  steps: WorkflowStep[];
+  variables: Record<string, any>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface WorkflowStep {
+  id: string;
+  name: string;
+  type: 'agent' | 'tool' | 'condition' | 'loop' | 'wait' | 'parallel';
+  config: Record<string, any>;
+  transitions: {
+    onSuccess?: string;
+    onFailure?: string;
+    onCondition?: {
+      condition: string;
+      target: string;
+    }[];
+  };
+}
+
+export class WorkflowEngine {
+  private workflows: Map<string, Workflow> = new Map();
+  private executions: Map<string, WorkflowExecution> = new Map();
+  
+  async create(params: CreateWorkflowParams): Promise<Workflow> {
+    const workflow: Workflow = {
+      id: generateId(),
+      name: params.name,
+      description: params.description,
+      steps: params.steps,
+      variables: params.variables || {},
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+    
+    this.workflows.set(workflow.id, workflow);
+    await this.persistWorkflow(workflow);
+    
+    return workflow;
+  }
+  
+  async run(workflowId: string, inputs?: Record<string, any>): Promise<WorkflowResult> {
+    const workflow = this.workflows.get(workflowId);
+    if (!workflow) {
+      throw new Error(`Workflow ${workflowId} not found`);
+    }
+    
+    const execution = new WorkflowExecution({
+      workflow,
+      inputs,
+      context: this.context
+    });
+    
+    this.executions.set(execution.id, execution);
+    
+    try {
+      const result = await execution.run();
+      return result;
+    } finally {
+      this.executions.delete(execution.id);
+    }
+  }
+  
+  async executeStep(step: WorkflowStep, context: ExecutionContext): Promise<StepResult> {
+    switch (step.type) {
+      case 'agent':
+        return this.executeAgentStep(step, context);
+      case 'tool':
+        return this.executeToolStep(step, context);
+      case 'condition':
+        return this.executeConditionStep(step, context);
+      case 'loop':
+        return this.executeLoopStep(step, context);
+      case 'wait':
+        return this.executeWaitStep(step, context);
+      case 'parallel':
+        return this.executeParallelStep(step, context);
+      default:
+        throw new Error(`Unknown step type: ${step.type}`);
+    }
+  }
+  
+  private async executeAgentStep(step: WorkflowStep, context: ExecutionContext): Promise<StepResult> {
+    const agent = await this.context.createAgent({
+      type: step.config.agentType || 'standard',
+      systemPrompt: step.config.systemPrompt
+    });
+    
+    const result = await agent.execute({
+      message: step.config.prompt,
+      context: context.variables
+    });
+    
+    return {
+      success: true,
+      output: result,
+      variables: {
+        [step.config.outputVar || 'result']: result
+      }
+    };
+  }
+  
+  private async executeToolStep(step: WorkflowStep, context: ExecutionContext): Promise<StepResult> {
+    const result = await this.context.callTool({
+      tool: step.config.tool,
+      params: this.interpolateParams(step.config.params, context.variables)
+    });
+    
+    return {
+      success: result.success,
+      output: result.data,
+      error: result.error,
+      variables: {
+        [step.config.outputVar || 'result']: result.data
+      }
+    };
+  }
+  
+  private interpolateParams(params: Record<string, any>, variables: Record<string, any>): Record<string, any> {
+    return JSON.parse(
+      JSON.stringify(params).replace(/\{\{(\w+)\}\}/g, (match, key) => {
+        return variables[key] ?? match;
+      })
+    );
+  }
+}
+```
+
+#### Day 5: Schedule Engine
+```typescript
+// extensions/xyops/src/schedule/engine.ts
+import { CronJob } from 'cron';
+
+export interface ScheduledJob {
+  id: string;
+  name: string;
+  workflowId: string;
+  cronExpression: string;
+  enabled: boolean;
+  inputs?: Record<string, any>;
+  timezone?: string;
+  lastRun?: Date;
+  nextRun?: Date;
+  runCount: number;
+}
+
+export class ScheduleEngine {
+  private jobs: Map<string, CronJob> = new Map();
+  private scheduledJobs: Map<string, ScheduledJob> = new Map();
+  
+  async schedule(params: ScheduleParams): Promise<ScheduledJob> {
+    const job: ScheduledJob = {
+      id: generateId(),
+      name: params.name,
+      workflowId: params.workflowId,
+      cronExpression: params.cron,
+      enabled: params.enabled ?? true,
+      inputs: params.inputs,
+      timezone: params.timezone,
+      runCount: 0
+    };
+    
+    this.scheduledJobs.set(job.id, job);
+    
+    if (job.enabled) {
+      await this.startJob(job);
+    }
+    
+    await this.persistJob(job);
+    return job;
+  }
+  
+  private async startJob(job: ScheduledJob): Promise<void> {
+    const cronJob = new CronJob(
+      job.cronExpression,
+      async () => {
+        await this.executeJob(job);
+      },
+      null,
+      true,
+      job.timezone
+    );
+    
+    this.jobs.set(job.id, cronJob);
+    job.nextRun = cronJob.nextDate().toJSDate();
+  }
+  
+  private async executeJob(job: ScheduledJob): Promise<void> {
+    console.log(`[Schedule] Executing job ${job.name} (${job.id})`);
+    
+    try {
+      const result = await this.workflowEngine.run(job.workflowId, job.inputs);
+      
+      job.lastRun = new Date();
+      job.runCount++;
+      job.nextRun = this.jobs.get(job.id)?.nextDate().toJSDate();
+      
+      await this.persistJob(job);
+      
+      // Notify on completion if configured
+      if (job.notifyOnComplete) {
+        await this.context.notify({
+          type: 'job_complete',
+          jobId: job.id,
+          result
+        });
+      }
+    } catch (error) {
+      console.error(`[Schedule] Job ${job.id} failed:`, error);
+      
+      if (job.notifyOnFailure) {
+        await this.context.notify({
+          type: 'job_failed',
+          jobId: job.id,
+          error: error.message
+        });
+      }
+    }
+  }
+  
+  parseNaturalLanguage(input: string): ScheduleParams {
+    // Use LLM to parse natural language into cron
+    // Examples:
+    // "every day at 9am" -> "0 9 * * *"
+    // "every Monday at 8am" -> "0 8 * * 1"
+    // "every hour" -> "0 * * * *"
+    
+    const patterns = [
+      {
+        regex: /every day at (\d+)(?::(\d+))?\s*(am|pm)?/i,
+        handler: (match) => {
+          let hour = parseInt(match[1]);
+          const minute = match[2] ? parseInt(match[2]) : 0;
+          const period = match[3]?.toLowerCase();
+          
+          if (period === 'pm' && hour !== 12) hour += 12;
+          if (period === 'am' && hour === 12) hour = 0;
+          
+          return `${minute} ${hour} * * *`;
+        }
+      },
+      {
+        regex: /every (\w+) at (\d+)(?::(\d+))?\s*(am|pm)?/i,
+        handler: (match) => {
+          const days = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+          const dayIndex = days.indexOf(match[1].toLowerCase());
+          if (dayIndex === -1) return null;
+          
+          let hour = parseInt(match[2]);
+          const minute = match[3] ? parseInt(match[3]) : 0;
+          const period = match[4]?.toLowerCase();
+          
+          if (period === 'pm' && hour !== 12) hour += 12;
+          if (period === 'am' && hour === 12) hour = 0;
+          
+          return `${minute} ${hour} * * ${dayIndex}`;
+        }
+      }
+    ];
+    
+    for (const pattern of patterns) {
+      const match = input.match(pattern.regex);
+      if (match) {
+        const cron = pattern.handler(match);
+        if (cron) {
+          return {
+            cron,
+            name: input,
+            // ... other params
+          };
+        }
+      }
+    }
+    
+    throw new Error(`Could not parse schedule: ${input}`);
+  }
+}
+```
+
+### Week 2: Monitoring & Visual Editor
+
+#### Day 6-7: Monitor Engine
+```typescript
+// extensions/xyops/src/monitor/engine.ts
+export interface HealthCheck {
+  id: string;
+  name: string;
+  target: string;
+  type: 'http' | 'tcp' | 'dns' | 'ping';
+  interval: number; // seconds
+  timeout: number;  // seconds
+  retries: number;
+  alerts: AlertConfig[];
+  status: 'up' | 'down' | 'unknown';
+  lastCheck?: Date;
+  lastSuccess?: Date;
+  consecutiveFailures: number;
+}
+
+export interface AlertConfig {
+  condition: 'down' | 'slow' | 'error_rate';
+  threshold?: number;
+  action: 'notify' | 'webhook' | 'workflow';
+  config: Record<string, any>;
+}
+
+export class MonitorEngine {
+  private checks: Map<string, HealthCheck> = new Map();
+  private intervals: Map<string, NodeJS.Timeout> = new Map();
+  
+  async addCheck(params: CreateCheckParams): Promise<HealthCheck> {
+    const check: HealthCheck = {
+      id: generateId(),
+      name: params.name,
+      target: params.target,
+      type: params.type,
+      interval: params.interval,
+      timeout: params.timeout || 30,
+      retries: params.retries || 3,
+      alerts: params.alerts || [],
+      status: 'unknown',
+      consecutiveFailures: 0
+    };
+    
+    this.checks.set(check.id, check);
+    
+    // Start monitoring
+    this.startCheck(check);
+    
+    await this.persistCheck(check);
+    return check;
+  }
+  
+  private startCheck(check: HealthCheck): void {
+    const interval = setInterval(async () => {
+      await this.runCheck(check);
+    }, check.interval * 1000);
+    
+    this.intervals.set(check.id, interval);
+  }
+  
+  private async runCheck(check: HealthCheck): Promise<void> {
+    const startTime = Date.now();
+    
+    try {
+      const result = await this.performCheck(check);
+      const responseTime = Date.now() - startTime;
+      
+      check.lastCheck = new Date();
+      
+      if (result.success) {
+        check.status = 'up';
+        check.lastSuccess = new Date();
+        check.consecutiveFailures = 0;
+      } else {
+        check.consecutiveFailures++;
+        
+        if (check.consecutiveFailures >= check.retries) {
+          check.status = 'down';
+          await this.triggerAlert(check, 'down', result.error);
+        }
+      }
+      
+      // Check for slow responses
+      if (responseTime > (check.timeout * 1000) / 2) {
+        await this.triggerAlert(check, 'slow', { responseTime });
+      }
+      
+    } catch (error) {
+      check.consecutiveFailures++;
+      
+      if (check.consecutiveFailures >= check.retries) {
+        check.status = 'down';
+        await this.triggerAlert(check, 'down', error.message);
+      }
+    }
+    
+    await this.persistCheck(check);
+  }
+  
+  private async performCheck(check: HealthCheck): Promise<CheckResult> {
+    switch (check.type) {
+      case 'http':
+        return this.checkHttp(check);
+      case 'tcp':
+        return this.checkTcp(check);
+      case 'dns':
+        return this.checkDns(check);
+      case 'ping':
+        return this.checkPing(check);
+      default:
+        throw new Error(`Unknown check type: ${check.type}`);
+    }
+  }
+  
+  private async checkHttp(check: HealthCheck): Promise<CheckResult> {
+    try {
+      const response = await fetch(check.target, {
+        method: 'GET',
+        signal: AbortSignal.timeout(check.timeout * 1000)
+      });
+      
+      return {
+        success: response.ok,
+        statusCode: response.status,
+        error: response.ok ? undefined : `HTTP ${response.status}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  
+  private async triggerAlert(check: HealthCheck, type: string, details: any): Promise<void> {
+    const matchingAlerts = check.alerts.filter(a => a.condition === type);
+    
+    for (const alert of matchingAlerts) {
+      switch (alert.action) {
+        case 'notify':
+          await this.context.notify({
+            type: 'monitor_alert',
+            checkId: check.id,
+            checkName: check.name,
+            alertType: type,
+            details
+          });
+          break;
+          
+        case 'webhook':
+          await fetch(alert.config.url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              check: check.name,
+              type,
+              details,
+              timestamp: new Date().toISOString()
+            })
+          });
+          break;
+          
+        case 'workflow':
+          await this.workflowEngine.run(alert.config.workflowId, {
+            checkId: check.id,
+            alertType: type,
+            details
+          });
+          break;
+      }
+    }
+  }
+}
+```
+
+#### Day 8-10: Visual Workflow Editor
+```typescript
+// extensions/xyops/src/web/components/WorkflowEditor.tsx
+import React, { useState, useCallback } from 'react';
+import ReactFlow, {
+  Node,
+  Edge,
+  addEdge,
+  Background,
+  Controls,
+  useNodesState,
+  useEdgesState,
+  Connection
+} from 'reactflow';
+import 'reactflow/dist/style.css';
+
+const nodeTypes = {
+  agent: AgentNode,
+  tool: ToolNode,
+  condition: ConditionNode,
+  loop: LoopNode,
+  wait: WaitNode
+};
+
+export const WorkflowEditor: React.FC = () => {
+  const [nodes, setNodes, onNodesChange] = useNodesState([]);
+  const [edges, setEdges, onEdgesChange] = useEdgesState([]);
+  const [selectedNode, setSelectedNode] = useState<Node | null>(null);
+  
+  const onConnect = useCallback(
+    (params: Connection) => setEdges((eds) => addEdge(params, eds)),
+    [setEdges]
+  );
+  
+  const addNode = (type: string) => {
+    const newNode: Node = {
+      id: generateId(),
+      type,
+      position: { x: 100, y: 100 },
+      data: { label: `${type} node` }
+    };
+    setNodes((nds) => [...nds, newNode]);
+  };
+  
+  const saveWorkflow = async () => {
+    const workflow = {
+      nodes,
+      edges,
+      // Convert to workflow format
+      steps: nodes.map(node => ({
+        id: node.id,
+        type: node.type,
+        config: node.data
+      }))
+    };
+    
+    await fetch('/api/workflows', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(workflow)
+    });
+  };
+  
+  return (
+    <div style={{ height: '100vh', display: 'flex' }}>
+      <div style={{ width: 250, padding: 20, borderRight: '1px solid #ddd' }}>
+        <h3>Toolbox</h3>
+        <button onClick={() => addNode('agent')}>Add Agent</button>
+        <button onClick={() => addNode('tool')}>Add Tool</button>
+        <button onClick={() => addNode('condition')}>Add Condition</button>
+        <button onClick={() => addNode('loop')}>Add Loop</button>
+        <button onClick={() => addNode('wait')}>Add Wait</button>
+        <hr />
+        <button onClick={saveWorkflow}>Save Workflow</button>
+      </div>
+      
+      <div style={{ flex: 1 }}>
+        <ReactFlow
+          nodes={nodes}
+          edges={edges}
+          onNodesChange={onNodesChange}
+          onEdgesChange={onEdgesChange}
+          onConnect={onConnect}
+          nodeTypes={nodeTypes}
+          onNodeClick={(_, node) => setSelectedNode(node)}
+          fitView
+        >
+          <Background />
+          <Controls />
+        </ReactFlow>
+      </div>
+      
+      {selectedNode && (
+        <NodeConfigPanel
+          node={selectedNode}
+          onUpdate={(data) => {
+            setNodes((nds) =>
+              nds.map((n) =>
+                n.id === selectedNode.id ? { ...n, data } : n
+              )
+            );
+          }}
+        />
+      )}
+    </div>
+  );
+};
+```
+
+### Week 3: Gateway Node & Integration
+
+#### Day 11-12: Gateway Node
+```typescript
+// extensions/xyops-gateway/src/node.ts
+import { GatewayNode } from '@poolbot/node-sdk';
+
+class XyOpsGatewayNode extends GatewayNode {
+  private workflowEngine: WorkflowEngine;
+  private scheduleEngine: ScheduleEngine;
+  private monitorEngine: MonitorEngine;
+  
+  async register() {
+    await this.send({
+      type: 'register',
+      payload: {
+        nodeId: this.nodeId,
+        capabilities: ['tools.workflow.*', 'tools.schedule.*', 'tools.monitor.*'],
+        tools: [
+          {
+            name: 'workflow.create',
+            description: 'Create a workflow',
+            parameters: { /* ... */ }
+          },
+          {
+            name: 'workflow.run',
+            description: 'Run a workflow',
+            parameters: { /* ... */ }
+          },
+          {
+            name: 'schedule.cron',
+            description: 'Schedule with cron',
+            parameters: { /* ... */ }
+          },
+          {
+            name: 'monitor.check',
+            description: 'Add health check',
+            parameters: { /* ... */ }
+          }
+        ]
+      }
+    });
+  }
+  
+  async handleToolCall(call: ToolCall) {
+    switch (call.tool) {
+      case 'workflow.create':
+        return this.workflowEngine.create(call.params);
+      case 'workflow.run':
+        return this.workflowEngine.run(call.params.workflowId, call.params.inputs);
+      case 'schedule.cron':
+        return this.scheduleEngine.schedule(call.params);
+      case 'monitor.check':
+        return this.monitorEngine.addCheck(call.params);
+      default:
+        throw new Error(`Unknown tool: ${call.tool}`);
+    }
+  }
+}
+```
+
+#### Day 13-14: CLI Integration
+```typescript
+// src/cli/mods.ts (enhancement)
+command('mods:xyops')
+  .description('Manage xyOps workflow automation')
+  .option('--workflow-create <name>', 'Create new workflow')
+  .option('--workflow-run <id>', 'Run workflow')
+  .option('--schedule-add <cron>', 'Add scheduled job')
+  .option('--monitor-add <target>', 'Add health check')
+  .option('--status', 'Show status')
+  .action(async (options) => {
+    if (options.workflowCreate) {
+      const workflow = await createWorkflowFromPrompt(options.workflowCreate);
+      console.log(`Created workflow: ${workflow.id}`);
+    }
+    // ...
+  });
+
+// Natural language workflow creation
+async function createWorkflowFromPrompt(prompt: string): Promise<Workflow> {
+  const agent = await createAgent({ type: 'standard' });
+  
+  const result = await agent.execute({
+    message: `
+      Create a workflow based on this request: "${prompt}"
+      
+      Return a JSON object with:
+      - name: workflow name
+      - steps: array of steps with type, name, and config
+      
+      Available step types:
+      - agent: AI agent execution
+      - tool: Tool call
+      - condition: If/else branch
+      - loop: Repeat steps
+      - wait: Delay execution
+    `
+  });
+  
+  return workflowEngine.create(result.parsed);
+}
+```
+
+#### Day 15: Testing & Documentation
+- Unit tests for all engines
+- Integration tests with Gateway
+- Visual editor tests
+- Documentation
+
+## File Structure
+
+```
+extensions/xyops/
+├── src/
+│   ├── plugin.ts              # PoolBot plugin entry
+│   ├── workflow/
+│   │   ├── engine.ts          # Workflow execution
+│   │   ├── execution.ts       # Execution context
+│   │   └── types.ts           # Type definitions
+│   ├── schedule/
+│   │   ├── engine.ts          # Cron scheduling
+│   │   └── types.ts
+│   ├── monitor/
+│   │   ├── engine.ts          # Health monitoring
+│   │   └── types.ts
+│   ├── web/
+│   │   ├── components/
+│   │   │   ├── WorkflowEditor.tsx
+│   │   │   ├── NodeConfigPanel.tsx
+│   │   │   └── NodeTypes/
+│   │   ├── App.tsx
+│   │   └── index.tsx
+│   └── index.ts
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Usage Examples
+
+### Example 1: Create Workflow
+```typescript
+const workflow = await agent.execute({
+  skill: 'workflow.create',
+  params: {
+    name: 'Daily Report',
+    steps: [
+      {
+        name: 'fetch_data',
+        type: 'tool',
+        config: {
+          tool: 'database.query',
+          params: { sql: 'SELECT * FROM sales WHERE date = TODAY' }
+        }
+      },
+      {
+        name: 'analyze',
+        type: 'agent',
+        config: {
+          prompt: 'Analyze this sales data and create a summary',
+          outputVar: 'summary'
+        }
+      },
+      {
+        name: 'send_report',
+        type: 'tool',
+        config: {
+          tool: 'email.send',
+          params: {
+            to: 'manager@company.com',
+            subject: 'Daily Sales Report',
+            body: '{{summary}}'
+          }
+        }
+      }
+    ]
+  }
+});
+```
+
+### Example 2: Schedule Workflow
+```typescript
+await agent.execute({
+  skill: 'schedule.cron',
+  params: {
+    workflowId: workflow.id,
+    cron: '0 9 * * *', // Every day at 9am
+    name: 'Daily morning report'
+  }
+});
+
+// Or use natural language
+await agent.execute({
+  skill: 'schedule.cron',
+  params: {
+    workflowId: workflow.id,
+    cron: 'natural:every weekday at 9am'
+  }
+});
+```
+
+### Example 3: Monitor Service
+```typescript
+await agent.execute({
+  skill: 'monitor.check',
+  params: {
+    name: 'API Health',
+    target: 'https://api.example.com/health',
+    type: 'http',
+    interval: 60,
+    alerts: [
+      {
+        condition: 'down',
+        action: 'notify'
+      },
+      {
+        condition: 'slow',
+        threshold: 5000,
+        action: 'webhook',
+        config: { url: 'https://alerts.example.com/webhook' }
+      }
+    ]
+  }
+});
+```
+
+## Success Criteria
+
+- [ ] Workflow engine functional
+- [ ] Schedule engine with cron support
+- [ ] Monitor engine with HTTP/TCP/DNS checks
+- [ ] Visual workflow editor
+- [ ] Natural language workflow creation
+- [ ] Gateway Node mode working
+- [ ] CLI integration complete
+- [ ] Tests pass (>80% coverage)
+- [ ] Documentation complete
+
+## Docker Support
+
+```dockerfile
+FROM node:20-alpine
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+EXPOSE 3000
+
+CMD ["node", "dist/node.js"]
+```