ofiere-openclaw-plugin 3.0.0 → 3.3.0

package/README.md

@@ -1,42 +1,27 @@
 # Ofiere PM Plugin for OpenClaw
 
-Manage your Ofiere PM dashboard directly from OpenClaw agents. Create tasks, update progress, assign agents — all synced to the dashboard in real time.
+Manage your Ofiere PM dashboard directly from OpenClaw agents. Create tasks, manage projects, build workflows, store knowledge — all synced to the dashboard in real time.
 
-## Install
+## Quick Install (One-Click)
 
 ```bash
-openclaw plugins install @ofiere-ai/openclaw-plugin
+curl -sSL https://raw.githubusercontent.com/gilanggemar/Ofiere/main/ofiere-openclaw-plugin/install.sh | bash -s -- \
+  --supabase-url "https://xxx.supabase.co" \
+  --service-key "eyJ..." \
+  --user-id "your-uuid"
 ```
 
-Or install from the local repo (for development):
+Only 3 parameters needed. All agents get the plugin automatically.
 
-```bash
-openclaw plugins install ./ofiere-openclaw-plugin
-```
-
-Restart OpenClaw after installing.
-
-## Setup
-
-```bash
-openclaw ofiere setup --supabase-url "https://xxx.supabase.co" --service-key "eyJ..." --user-id "your-uuid" --agent-id "sasha"
-```
-
-Or run interactively:
+## Uninstall
 
 ```bash
-openclaw ofiere setup
+curl -sSL https://raw.githubusercontent.com/gilanggemar/Ofiere/main/ofiere-openclaw-plugin/uninstall.sh | bash
 ```
 
-Then restart the gateway:
-
-```bash
-openclaw gateway restart
-```
+## How It Works
 
-## How it works
-
-Once configured, the plugin connects to your Supabase database at gateway startup and registers PM tools directly into the agent. There's no separate MCP server process — it runs inside the OpenClaw gateway for maximum reliability.
+Once configured, the plugin connects to your Supabase database at gateway startup and registers 9 PM meta-tools directly into the agent. There's no separate MCP server process — it runs inside the OpenClaw gateway for maximum reliability.
 
 Changes made by the agent are immediately visible on the Ofiere dashboard (Vercel) via Supabase real-time subscriptions.
 
@@ -46,20 +31,38 @@ The plugin uses a scalable meta-tool architecture. Each tool handles one domain
 
 | Tool | Actions | Description |
 |---|---|---|
-| `OFIERE_TASK_OPS` | `list`, `create`, `update`, `delete` | Manage PM tasks — list, create, update status/priority, delete |
+| `OFIERE_TASK_OPS` | `list`, `create`, `update`, `delete` | Rich task management with execution plans, goals, constraints |
 | `OFIERE_AGENT_OPS` | `list` | Query available agents for task assignment |
+| `OFIERE_PROJECT_OPS` | `list_spaces`, `create_space`, `create_folder`, `bulk_create_tasks`, etc. | Full project hierarchy: spaces → folders → tasks |
+| `OFIERE_SCHEDULE_OPS` | `list`, `create`, `update`, `delete` | Calendar events with recurrence |
+| `OFIERE_KNOWLEDGE_OPS` | `search`, `list`, `create`, `update`, `delete` | Knowledge library with full content retrieval |
+| `OFIERE_WORKFLOW_OPS` | `list`, `get`, `create`, `update`, `delete`, `list_runs`, `trigger` | Visual workflow builder with 16 node types |
+| `OFIERE_NOTIFY_OPS` | `list`, `mark_read`, `create` | In-app notifications |
+| `OFIERE_MEMORY_OPS` | `list_conversations`, `search_knowledge` | Conversation history & agent memory |
+| `OFIERE_PROMPT_OPS` | `list`, `get`, `create`, `update`, `delete` | System prompt chunk management |
 
 ### Example
 
 ```
-// Create a task
-OFIERE_TASK_OPS({ action: "create", title: "Deploy v2", agent_id: "ivy" })
-
-// List tasks
-OFIERE_TASK_OPS({ action: "list", status: "PENDING", limit: 10 })
-
-// Update a task
-OFIERE_TASK_OPS({ action: "update", task_id: "task-123", status: "DONE" })
+// Create a task with execution plan
+OFIERE_TASK_OPS({ action: "create", title: "Deploy v2", agent_id: "ivy",
+  execution_plan: [{ step: 1, action: "Build", detail: "Run production build" }] })
+
+// Create a workflow with nodes
+OFIERE_WORKFLOW_OPS({ action: "create", name: "Deploy Pipeline",
+  nodes: [
+    { type: "agent_step", data: { label: "Build", task: "Run npm build" } },
+    { type: "human_approval", data: { label: "Review", instructions: "Check build output" } },
+    { type: "output", data: { label: "Done" } }
+  ],
+  edges: [
+    { source: "agent_step-...", target: "human_approval-..." },
+    { source: "human_approval-...", target: "output-..." }
+  ]
+})
+
+// Search knowledge library
+OFIERE_KNOWLEDGE_OPS({ action: "search", query: "API rate limits" })
 ```
 
 ## CLI Commands
@@ -79,7 +82,7 @@ Set via `openclaw ofiere setup` or environment variables:
 | `supabaseUrl` | `OFIERE_SUPABASE_URL` | Supabase project URL |
 | `serviceRoleKey` | `OFIERE_SERVICE_ROLE_KEY` | Supabase service role key |
 | `userId` | `OFIERE_USER_ID` | Your user UUID |
-| `agentId` | `OFIERE_AGENT_ID` | This agent's ID (e.g. `sasha`) |
+| `agentId` | `OFIERE_AGENT_ID` | This agent's ID (optional — auto-detected) |
 | `enabled` | — | Enable/disable the plugin (default: `true`) |
 
 ## Architecture

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "3.0.0",
+  "version": "3.3.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM — 9 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, and prompts",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/prompt.ts

@@ -11,7 +11,8 @@
 const TOOL_DOCS: Record<string, string> = {
   OFIERE_TASK_OPS: `- **OFIERE_TASK_OPS** — Manage tasks (action: "list", "create", "update", "delete")
     - list: Filter by status, agent_id, space_id, folder_id, limit. Returns execution_plan, goals, constraints if present
-    - create: Requires title. Optional: agent_id, description, instructions, execution_plan, goals, constraints, system_prompt, priority, tags, dates
+    - create: Requires title. IMPORTANT: Always pass agent_id with your own name to self-assign (e.g. agent_id: "celia")
+      - Optional: description, instructions, execution_plan, goals, constraints, system_prompt, priority, tags, dates
       - For COMPLEX tasks: include execution_plan (step-by-step), goals, constraints, and system_prompt
       - For SIMPLE tasks: just title and optionally description
     - update: Requires task_id. All create fields + progress
@@ -32,16 +33,22 @@ const TOOL_DOCS: Record<string, string> = {
     - create: Requires title + scheduled_date (YYYY-MM-DD). Optional: scheduled_time, duration_minutes, task_id, agent_id, recurrence_type, color
     - Recurrence: none, hourly, daily, weekly, monthly with interval`,
 
-  OFIERE_KNOWLEDGE_OPS: `- **OFIERE_KNOWLEDGE_OPS** — Knowledge base documents (action: "search", "list", "create", "update", "delete")
-    - search: Keyword search across all docs. Requires: query
-    - list: Paginated listing with optional search filter
-    - create: Add knowledge. Requires: file_name. Optional: content, source, author, credibility_tier
+  OFIERE_KNOWLEDGE_OPS: `- **OFIERE_KNOWLEDGE_OPS** — Ofiere Knowledge Library (action: "search", "list", "create", "update", "delete")
+    - ALWAYS use this tool when the user mentions "knowledge base", "knowledge library", "knowledge entries", or asks to recall/retrieve stored knowledge
+    - search: Keyword search across all stored documents. Requires: query
+    - list: Paginated listing of knowledge entries with full content. Optional: search filter
+    - create: Add knowledge to the library. Requires: file_name. Optional: content, source, author, credibility_tier
     - update/delete: By document ID`,
 
-  OFIERE_WORKFLOW_OPS: `- **OFIERE_WORKFLOW_OPS** — Automated workflows (action: "list", "get", "create", "list_runs", "trigger")
+  OFIERE_WORKFLOW_OPS: `- **OFIERE_WORKFLOW_OPS** — Automated workflows (action: "list", "get", "create", "update", "delete", "list_runs", "trigger")
     - list: All workflows, filter by status (draft, active, paused, archived)
     - get: Full workflow details by ID
-    - create: New workflow with name, steps, schedule
+    - create: New workflow with name + nodes and edges
+      - Node types: manual_trigger, agent_step, http_request, formatter_step, task_call, variable_set, condition, human_approval, delay, loop, convergence, output, checkpoint, note
+      - Each node: { type, data: { label, ...type-specific fields } }. IDs/positions auto-generated
+      - Edges: { source, target }. A manual_trigger is auto-prepended if no trigger exists
+    - update: Modify workflow (name, description, status, nodes, edges)
+    - delete: Remove workflow and all run history
     - list_runs: Recent execution history for a workflow
     - trigger: Start a workflow run (creates a run record)`,
 
@@ -58,9 +65,10 @@ const TOOL_DOCS: Record<string, string> = {
     - search_knowledge: Search stored knowledge for an agent`,
 
   OFIERE_PROMPT_OPS: `- **OFIERE_PROMPT_OPS** — Manage prompt instruction chunks (action: "list", "get", "create", "update", "delete")
-    - list: All prompt chunks, filter by agent_id
-    - create: New chunk with label + content. These modify agent behavior
-    - update: Change label, content, enabled state, or sort_order
+    - list: All prompt chunks ordered by display order
+    - create: New chunk with name (max 30 chars) + content. Optional: color (hex), category
+    - update: Change name, content, color, category, or order
+    - delete: Remove a chunk by ID
     - All modifications are logged for audit`,
 };
 
@@ -93,6 +101,7 @@ Each tool uses an "action" parameter to select the operation. Always include act
 ${toolDocs}
 
 ## Rules
+- ALWAYS pass agent_id with your own name when creating tasks (e.g. agent_id: "ivy"). Auto-detection is NOT reliable.
 - ${assignRule}
 - To create an unassigned task, pass agent_id as "none" or "unassigned".
 - When the user says "create a task for [agent name]", use OFIERE_AGENT_OPS action:"list" to find the agent ID, then use OFIERE_TASK_OPS action:"create" with that agent_id.
@@ -104,6 +113,7 @@ ${toolDocs}
 - For complex tasks, ALWAYS include execution_plan, goals, and constraints. For simple tasks, just title is enough.
 - When creating dependencies, use OFIERE_PROJECT_OPS to link predecessor/successor tasks.
 - Prompt chunk modifications (OFIERE_PROMPT_OPS) are powerful — use thoughtfully as they change agent behavior.
+- When the user asks about "knowledge base", "knowledge library", "knowledge entries", or wants to recall stored knowledge, ALWAYS use OFIERE_KNOWLEDGE_OPS — do NOT rely on your own memory for this.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -106,6 +106,17 @@ export function probeApiForAgentName(api: any, logger?: any): string {
 
 // ─── Shared: Agent ID Resolution ─────────────────────────────────────────────
 
+// System/plugin names that should never be treated as real agent identifiers.
+// These come from the OpenClaw gateway registration context, not from actual agents.
+const SYSTEM_NAME_BLOCKLIST = new Set([
+  "ofiere pm", "ofiere", "openclaw", "system", "plugin", "gateway", "admin",
+  "ofiere pm plugin", "ofiere-openclaw-plugin",
+]);
+
+function isSystemName(name: string): boolean {
+  return SYSTEM_NAME_BLOCKLIST.has(name.toLowerCase().trim());
+}
+
 function createAgentResolver(
   api: any,
   supabase: SupabaseClient,
@@ -114,47 +125,38 @@ function createAgentResolver(
 ) {
   /**
    * Resolve the agent ID for the calling agent.
-   * Priority: explicit param > runtime context > registration-time detection > env var > DB fallback
+   * Priority: explicit param > env var > DB fallback
+   *
+   * NOTE: We intentionally skip runtime/registration detection because the
+   * OpenClaw api object returns the PLUGIN name ("Ofiere PM"), not the
+   * calling agent's name. Each agent must pass its own name via agent_id.
    */
   return async function resolveAgent(explicitId?: string): Promise<string | null> {
-    // 1. Explicit agent_id passed by the LLM (e.g. "ivy", "daisy", or a UUID)
+    // 1. Explicit agent_id passed by the LLM (e.g. "ivy", "celia", or a UUID)
     if (explicitId && explicitId.trim()) {
       const trimmed = explicitId.trim();
-      // If it looks like a UUID or our ID format, use directly
-      if (trimmed.match(/^[0-9a-f]{8}-/) || trimmed.match(/^agent-/)) {
-        return trimmed;
-      }
-      // Otherwise treat as a name and resolve to the actual agent ID
-      try {
-        return await resolveAgentId(trimmed, userId, supabase);
-      } catch {
-        return trimmed; // fallback: use as-is
-      }
-    }
 
-    // 2. Runtime: read calling agent's name from OpenClaw context
-    const callerName = getCallingAgentName(api);
-    if (callerName) {
-      try {
-        return await resolveAgentId(callerName, userId, supabase);
-      } catch {
-        // Fall through
-      }
-    }
-
-    // 3. Registration-time detection (set when plugin was loaded)
-    if (_registrationAgentName) {
-      try {
-        return await resolveAgentId(_registrationAgentName, userId, supabase);
-      } catch {
-        // Fall through
+      // Block system names from being used as agent IDs
+      if (isSystemName(trimmed)) {
+        // Fall through to DB fallback
+      } else if (trimmed.match(/^[0-9a-f]{8}-/) || trimmed.match(/^agent-/)) {
+        // Looks like a UUID or our ID format — use directly
+        return trimmed;
+      } else {
+        // Treat as a name and resolve to the actual agent ID
+        try {
+          const resolved = await resolveAgentId(trimmed, userId, supabase);
+          if (resolved && !isSystemName(resolved)) return resolved;
+        } catch {
+          // Fall through
+        }
       }
     }
 
-    // 4. Env var fallback (OFIERE_AGENT_ID — legacy single-agent mode)
+    // 2. Env var fallback (OFIERE_AGENT_ID — legacy single-agent mode)
     if (fallbackAgentId) return fallbackAgentId;
 
-    // 5. Nuclear fallback: query the FIRST agent for this user
+    // 3. Nuclear fallback: query the FIRST agent for this user
     try {
       const { data } = await supabase
         .from("agents")
@@ -343,7 +345,7 @@ async function handleCreateTask(
   try {
     if (!params.title) return err("Missing required field: title");
 
-    const id = `task-${Date.now()}`;
+    const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const now = new Date().toISOString();
 
     // Handle explicit "none"/"unassigned"
@@ -421,17 +423,98 @@ async function handleCreateTask(
       return err(error.message);
     }
 
+    // ── Auto-create scheduler event if task has a start_date ──────────────
+    // This bridges the plugin → scheduler so the pg_cron task-dispatcher
+    // Edge Function picks up the task at the right time.
+    const startDate = params.start_date as string | undefined;
+    const effectiveAgentId = (insertData.agent_id as string) || assignee;
+    if (startDate && effectiveAgentId) {
+      try {
+        // Parse start_date robustly — it can be:
+        //   "2026-04-19"                    (date only)
+        //   "2026-04-19T18:45:00"           (local datetime)
+        //   "2026-04-19 11:45:00+00"        (Supabase timestamptz)
+        //   "2026-04-19T11:45:00.000Z"      (ISO UTC)
+        const parsedDate = new Date(startDate);
+        const explicitScheduledTime = params.scheduled_time as string | undefined;
+
+        let nextRunAtEpoch: number;
+        let scheduledTimeFinal: string;
+        let scheduledDateFinal: string;
+
+        if (!isNaN(parsedDate.getTime())) {
+          // Valid date — check if it includes a meaningful time component
+          const hasTimeInfo = /[T ]\d{2}:\d{2}/.test(startDate);
+
+          if (explicitScheduledTime) {
+            // Agent explicitly passed a scheduled_time — use date from start_date + explicit time
+            const dateStr = parsedDate.toISOString().split("T")[0]; // YYYY-MM-DD
+            const dt = new Date(`${dateStr}T${explicitScheduledTime}:00Z`);
+            nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
+            scheduledTimeFinal = explicitScheduledTime;
+            scheduledDateFinal = dateStr;
+          } else if (hasTimeInfo) {
+            // start_date already contains time — use it directly
+            nextRunAtEpoch = Math.floor(parsedDate.getTime() / 1000);
+            scheduledTimeFinal = `${String(parsedDate.getUTCHours()).padStart(2, "0")}:${String(parsedDate.getUTCMinutes()).padStart(2, "0")}`;
+            scheduledDateFinal = parsedDate.toISOString().split("T")[0];
+          } else {
+            // Date only, no time — default to 09:00 UTC
+            const dateStr = parsedDate.toISOString().split("T")[0];
+            const dt = new Date(`${dateStr}T09:00:00Z`);
+            nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
+            scheduledTimeFinal = "09:00";
+            scheduledDateFinal = dateStr;
+          }
+        } else {
+          // Unparseable date — fallback to now + 60s
+          nextRunAtEpoch = Math.floor(Date.now() / 1000) + 60;
+          scheduledTimeFinal = "00:00";
+          scheduledDateFinal = new Date().toISOString().split("T")[0];
+        }
+
+        // Safety net: if computed time is in the past, schedule for now + 60s
+        const nowEpoch = Math.floor(Date.now() / 1000);
+        if (nextRunAtEpoch <= nowEpoch) {
+          nextRunAtEpoch = nowEpoch + 60;
+        }
+
+        await supabase.from("scheduler_events").insert({
+          id: crypto.randomUUID(),
+          user_id: userId,
+          task_id: id,
+          agent_id: effectiveAgentId,
+          title: params.title,
+          description: (params.description as string) || (params.instructions as string) || null,
+          scheduled_date: scheduledDateFinal,
+          scheduled_time: scheduledTimeFinal,
+          duration_minutes: 30,
+          recurrence_type: "none",
+          recurrence_interval: 1,
+          status: "scheduled",
+          next_run_at: nextRunAtEpoch,
+          run_count: 0,
+          priority: params.priority !== undefined ? params.priority : 1,
+        });
+      } catch (schedErr) {
+        // Non-fatal: task was created, just the scheduler event failed
+        console.error("[ofiere] Failed to auto-create scheduler event:", schedErr);
+      }
+    }
+
     const extras = [];
     if (cf.execution_plan) extras.push(`${(cf.execution_plan as any[]).length} execution steps`);
     if (cf.goals) extras.push(`${(cf.goals as any[]).length} goals`);
     if (cf.constraints) extras.push(`${(cf.constraints as any[]).length} constraints`);
     if (cf.system_prompt) extras.push("custom system prompt");
+    if (startDate) extras.push(`scheduled for ${startDate}`);
     const extrasStr = extras.length > 0 ? ` with ${extras.join(", ")}` : "";
 
     return ok({
       id,
       message: `Task "${params.title}" created and assigned to ${assignee || "no one"}${extrasStr}`,
       task: insertData,
+      scheduledExecution: startDate ? `Will auto-execute on ${startDate}` : undefined,
     });
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
@@ -516,7 +599,7 @@ async function handleUpdateTask(
       .update(updates)
       .eq("id", params.task_id as string)
       .eq("user_id", userId)
-      .select("id, title, status, priority, agent_id")
+      .select("id, title, status, priority, agent_id, start_date, due_date, progress, updated_at")
       .single();
 
     if (error) return err(error.message);
@@ -934,11 +1017,12 @@ function registerKnowledgeOps(
     name: "OFIERE_KNOWLEDGE_OPS",
     label: "Ofiere Knowledge Operations",
     description:
-      `Search, add, and manage knowledge documents. This is the long-term memory system.\n\n` +
+      `Access the Ofiere Knowledge Library — the stored knowledge base in the dashboard. ` +
+      `Use this tool whenever the user mentions "knowledge base", "knowledge library", "knowledge entries", or asks to retrieve stored knowledge.\n\n` +
       `Actions:\n` +
-      `- "search": Search docs by keyword. Required: query. Optional: limit\n` +
-      `- "list": List recent docs. Optional: page, page_size, search\n` +
-      `- "create": Add a document. Required: file_name. Optional: content, text, source, source_type, author, credibility_tier\n` +
+      `- "search": Search the knowledge library by keyword. Required: query. Optional: limit\n` +
+      `- "list": List recent entries from the knowledge library. Optional: page, page_size, search\n` +
+      `- "create": Add a document to the knowledge library. Required: file_name. Optional: content, text, source, source_type, author, credibility_tier\n` +
       `- "update": Edit a document. Required: id. Optional: file_name, content, text, source, source_type, author\n` +
       `- "delete": Remove a document. Required: id`,
     parameters: {
@@ -983,7 +1067,7 @@ function registerKnowledgeOps(
           const from = (page - 1) * pageSize;
           const to = from + pageSize - 1;
           let q = supabase.from("knowledge_documents")
-            .select("id, file_name, file_type, source, source_type, author, credibility_tier, created_at", { count: "exact" })
+            .select("id, file_name, file_type, content, text, source, source_type, author, credibility_tier, created_at", { count: "exact" })
             .order("created_at", { ascending: false })
             .range(from, to);
           if (params.search) {
@@ -1050,23 +1134,75 @@ function registerWorkflowOps(
     name: "OFIERE_WORKFLOW_OPS",
     label: "Ofiere Workflow Operations",
     description:
-      `Manage and trigger automated workflows.\n\n` +
+      `Manage, build, and trigger automated workflows in the Ofiere dashboard.\n\n` +
       `Actions:\n` +
       `- "list": List all workflows. Optional: status\n` +
       `- "get": Get workflow details. Required: id\n` +
-      `- "create": Create a workflow. Required: name. Optional: description, steps, schedule, status\n` +
+      `- "create": Create a workflow WITH nodes and edges. Required: name. Optional: description, nodes, edges, schedule, status\n` +
+      `- "update": Update a workflow. Required: id. Optional: name, description, status, nodes, edges, schedule\n` +
+      `- "delete": Delete a workflow and its run history. Required: id\n` +
       `- "list_runs": List recent runs. Required: workflow_id. Optional: limit\n` +
-      `- "trigger": Start a workflow run. Required: workflow_id`,
+      `- "trigger": Start a workflow run. Required: workflow_id\n\n` +
+      `NODE TYPES (use these exact types when creating nodes):\n` +
+      `  TRIGGERS (start of workflow — pick one):\n` +
+      `    - "manual_trigger": User clicks Execute to start\n` +
+      `    - "webhook_trigger": External HTTP request triggers it\n` +
+      `    - "schedule_trigger": Runs on cron schedule. data: { label, cron: "0 9 * * 1-5" }\n` +
+      `  STEPS (the work):\n` +
+      `    - "agent_step": Delegates task to an AI agent. data: { label, agentId, task, responseMode: "text", timeoutSec: 120 }\n` +
+      `    - "http_request": Calls an external API. data: { label, method: "GET"|"POST", url }\n` +
+      `    - "formatter_step": Formats/transforms text or JSON. data: { label, template }\n` +
+      `    - "task_call": Runs a saved task. data: { label, agentId, taskId }\n` +
+      `    - "variable_set": Stores data in a variable. data: { label, variableName, variableValue }\n` +
+      `  CONTROL FLOW:\n` +
+      `    - "condition": If/else branch. data: { label, expression }\n` +
+      `    - "human_approval": Pauses for human approval. data: { label, instructions }\n` +
+      `    - "delay": Waits for a set time. data: { label, delaySec: 5 }\n` +
+      `    - "loop": Repeats actions. data: { label, loopType: "count", maxIterations: 3 }\n` +
+      `    - "convergence": Waits for multiple parallel inputs. data: { label, mergeStrategy: "wait_all" }\n` +
+      `  END:\n` +
+      `    - "output": Returns final result. data: { label, outputMode: "return" }\n` +
+      `  SPECIAL:\n` +
+      `    - "checkpoint": Loop target marker. data: { label }\n` +
+      `    - "note": Sticky note annotation. data: { label, noteText }\n\n` +
+      `Each node: { type, data: { label, ... }, position?: { x, y } }. IDs and positions are auto-generated if omitted.\n` +
+      `Each edge: { source: "node_id", target: "node_id" }. IDs auto-generated.\n` +
+      `A manual_trigger node is always auto-prepended if no trigger node is included.`,
     parameters: {
       type: "object",
       required: ["action"],
       properties: {
-        action: { type: "string", enum: ["list", "get", "create", "list_runs", "trigger"] },
+        action: { type: "string", enum: ["list", "get", "create", "update", "delete", "list_runs", "trigger"] },
         id: { type: "string", description: "Workflow ID" },
         workflow_id: { type: "string", description: "Workflow ID for runs/trigger" },
         name: { type: "string", description: "Workflow name" },
         description: { type: "string" },
-        steps: { type: "array", items: { type: "object" }, description: "Workflow step definitions" },
+        nodes: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "Node ID (auto-generated if omitted)" },
+              type: { type: "string", enum: ["manual_trigger", "webhook_trigger", "schedule_trigger", "agent_step", "formatter_step", "http_request", "task_call", "variable_set", "condition", "human_approval", "delay", "loop", "convergence", "output", "checkpoint", "note"] },
+              position: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } },
+              data: { type: "object", description: "Node config — always include a 'label' field. See NODE TYPES above for type-specific fields." },
+            },
+          },
+          description: "Workflow graph nodes",
+        },
+        edges: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "Edge ID (auto-generated if omitted)" },
+              source: { type: "string", description: "Source node ID" },
+              target: { type: "string", description: "Target node ID" },
+            },
+          },
+          description: "Connections between nodes. Each edge: { source, target }",
+        },
+        steps: { type: "array", items: { type: "object" }, description: "Legacy V1 step definitions" },
         schedule: { type: "string", description: "Cron expression or schedule" },
         status: { type: "string", enum: ["draft", "active", "paused", "archived"] },
         limit: { type: "number", description: "Max results" },
@@ -1074,6 +1210,43 @@ function registerWorkflowOps(
     },
     async execute(_id: string, params: Record<string, unknown>) {
       const action = params.action as string;
+
+      // Default data for each node type — ensures dashboard renders them properly
+      const NODE_DEFAULTS: Record<string, Record<string, any>> = {
+        manual_trigger: { label: "Execute Trigger" },
+        webhook_trigger: { label: "Webhook Trigger" },
+        schedule_trigger: { label: "Schedule Trigger", cron: "0 9 * * 1-5" },
+        agent_step: { label: "Agent Step", agentId: "", task: "", responseMode: "text", timeoutSec: 120 },
+        formatter_step: { label: "Formatter", template: "" },
+        http_request: { label: "HTTP Request", method: "GET", url: "" },
+        task_call: { label: "Task", agentId: "", taskId: "", taskTitle: "", agentName: "" },
+        variable_set: { label: "Set Variable", variableName: "", variableValue: "" },
+        condition: { label: "Condition", expression: "" },
+        human_approval: { label: "Human Approval", instructions: "" },
+        delay: { label: "Delay", delaySec: 5 },
+        loop: { label: "Loop", loopType: "count", maxIterations: 3 },
+        convergence: { label: "Convergence", mergeStrategy: "wait_all" },
+        output: { label: "Output", outputMode: "return" },
+        checkpoint: { label: "Checkpoint" },
+        note: { label: "Note", noteText: "" },
+      };
+
+      // Valid node types
+      const VALID_TYPES = new Set(Object.keys(NODE_DEFAULTS));
+
+      // Helper: normalize a single node with defaults and auto-ID
+      function normalizeNode(n: any, i: number) {
+        let type = n.type || "agent_step";
+        if (!VALID_TYPES.has(type)) type = "agent_step"; // fallback invalid types
+        const defaults = NODE_DEFAULTS[type] || {};
+        return {
+          id: n.id || `${type}-${Date.now()}-${i}`,
+          type,
+          position: n.position || { x: 250, y: 80 + i * 150 },
+          data: { ...defaults, ...(n.data || {}), label: n.data?.label || defaults.label || type },
+        };
+      }
+
       switch (action) {
         case "list": {
           let q = supabase.from("workflows").select("*").eq("user_id", userId).order("updated_at", { ascending: false });
@@ -1095,6 +1268,54 @@ function registerWorkflowOps(
           const stepsWithIds = ((params.steps as any[]) || []).map((s: any, i: number) => ({
             ...s, id: s.id || `step-${i}`,
           }));
+
+          // Build nodes — normalize provided nodes
+          let rawNodes = (params.nodes as any[]) || [];
+          let finalNodes = rawNodes.map((n, i) => normalizeNode(n, i));
+
+          // Auto-prepend a trigger node if none is present
+          const hasTrigger = finalNodes.some(n => n.type.includes("trigger"));
+          if (!hasTrigger) {
+            const triggerNode = {
+              id: `manual_trigger-${Date.now()}`,
+              type: "manual_trigger",
+              position: { x: 100, y: 200 },
+              data: { label: "Execute Trigger" },
+            };
+            // Shift all other nodes to the right
+            finalNodes = finalNodes.map(n => ({
+              ...n,
+              position: { x: (n.position?.x || 250) + 200, y: n.position?.y || 200 },
+            }));
+            finalNodes.unshift(triggerNode);
+          }
+
+          // Build edges — ensure IDs exist
+          let finalEdges = (params.edges as any[]) || [];
+          finalEdges = finalEdges.map((e: any, i: number) => ({
+            id: e.id || `edge-${Date.now()}-${i}`,
+            source: e.source,
+            target: e.target,
+            ...(e.sourceHandle ? { sourceHandle: e.sourceHandle } : {}),
+            ...(e.targetHandle ? { targetHandle: e.targetHandle } : {}),
+          }));
+
+          // Auto-wire trigger to first non-trigger node if no edge connects from trigger
+          if (hasTrigger === false && finalNodes.length > 1 && finalEdges.length === 0) {
+            // No edges at all — auto-connect trigger → first step
+          } else if (hasTrigger === false && finalNodes.length > 1) {
+            const triggerId = finalNodes[0].id;
+            const firstStepId = finalNodes[1].id;
+            const triggerHasEdge = finalEdges.some(e => e.source === triggerId);
+            if (!triggerHasEdge) {
+              finalEdges.unshift({
+                id: `edge-trigger-${Date.now()}`,
+                source: triggerId,
+                target: firstStepId,
+              });
+            }
+          }
+
           const { data, error } = await supabase.from("workflows").insert({
             id: wfId, user_id: userId,
             name: params.name,
@@ -1102,10 +1323,46 @@ function registerWorkflowOps(
             steps: stepsWithIds,
             schedule: (params.schedule as string) || null,
             status: (params.status as string) || "draft",
-            nodes: [], edges: [], definition_version: 1,
+            nodes: finalNodes,
+            edges: finalEdges,
+            definition_version: 2,
           }).select().single();
           if (error) return err(error.message);
-          return ok({ message: `Workflow "${params.name}" created`, workflow: data });
+          return ok({
+            message: `Workflow "${params.name}" created with ${finalNodes.length} node(s) and ${finalEdges.length} edge(s)`,
+            workflow: data,
+          });
+        }
+        case "update": {
+          const wfId = (params.id || params.workflow_id) as string;
+          if (!wfId) return err("Missing required: id");
+          const upd: Record<string, any> = { updated_at: new Date().toISOString() };
+          for (const f of ["name", "description", "status", "steps", "schedule", "nodes", "edges"]) {
+            if ((params as any)[f] !== undefined) upd[f] = (params as any)[f];
+          }
+          // Normalize nodes using the same defaults as create
+          if (upd.nodes && Array.isArray(upd.nodes)) {
+            upd.nodes = upd.nodes.map((n: any, i: number) => normalizeNode(n, i));
+          }
+          if (upd.edges && Array.isArray(upd.edges)) {
+            upd.edges = upd.edges.map((e: any, i: number) => ({
+              id: e.id || `edge-${Date.now()}-${i}`,
+              source: e.source,
+              target: e.target,
+            }));
+          }
+          const { data, error } = await supabase.from("workflows").update(upd).eq("id", wfId).eq("user_id", userId).select().single();
+          if (error) return err(error.message);
+          return ok({ message: "Workflow updated", workflow: data });
+        }
+        case "delete": {
+          const wfId = (params.id || params.workflow_id) as string;
+          if (!wfId) return err("Missing required: id");
+          // Delete associated runs first
+          await supabase.from("workflow_runs").delete().eq("workflow_id", wfId);
+          const { error } = await supabase.from("workflows").delete().eq("id", wfId).eq("user_id", userId);
+          if (error) return err(error.message);
+          return ok({ message: "Workflow and associated runs deleted", ok: true });
         }
         case "list_runs": {
           const wfId = (params.workflow_id || params.id) as string;
@@ -1323,10 +1580,10 @@ function registerPromptOps(
     description:
       `Manage system prompt instruction chunks. These are the building blocks of agent behavior.\n\n` +
       `Actions:\n` +
-      `- "list": List all prompt chunks. Optional: agent_id\n` +
+      `- "list": List all prompt chunks\n` +
       `- "get": Get a specific chunk. Required: id\n` +
-      `- "create": Create a new chunk. Required: label, content. Optional: agent_id, sort_order\n` +
-      `- "update": Update a chunk. Required: id. Optional: label, content, enabled, sort_order\n` +
+      `- "create": Create a new chunk. Required: name, content. Optional: color (hex), category\n` +
+      `- "update": Update a chunk. Required: id. Optional: name, content, color, category, order\n` +
       `- "delete": Delete a chunk. Required: id`,
     parameters: {
       type: "object",
@@ -1334,59 +1591,69 @@ function registerPromptOps(
       properties: {
         action: { type: "string", enum: ["list", "get", "create", "update", "delete"] },
         id: { type: "string", description: "Chunk ID" },
-        label: { type: "string", description: "Chunk label/name" },
-        content: { type: "string", description: "Prompt chunk content" },
-        agent_id: { type: "string", description: "Associate with specific agent" },
-        enabled: { type: "boolean", description: "Whether chunk is active" },
-        sort_order: { type: "number", description: "Display order" },
+        name: { type: "string", description: "Chunk name/label (max 30 chars)" },
+        content: { type: "string", description: "Prompt chunk content text" },
+        color: { type: "string", description: "Hex color for display (e.g. #6B7280)" },
+        category: { type: "string", description: "Category grouping (e.g. Personality, Instructions)" },
+        order: { type: "number", description: "Display order (0-based)" },
       },
     },
     async execute(_id: string, params: Record<string, unknown>) {
       const action = params.action as string;
       switch (action) {
         case "list": {
-          let q = supabase.from("prompt_chunks").select("*").eq("user_id", userId).order("sort_order");
-          if (params.agent_id) q = q.eq("agent_id", params.agent_id as string);
-          const { data, error } = await q;
+          const { data, error } = await supabase.from("prompt_chunks").select("*").eq("user_id", userId).order("order", { ascending: true });
           if (error) return err(error.message);
           return ok({ chunks: data || [], count: (data || []).length });
         }
         case "get": {
           if (!params.id) return err("Missing required: id");
-          const { data, error } = await supabase.from("prompt_chunks").select("*").eq("id", params.id).single();
+          const { data, error } = await supabase.from("prompt_chunks").select("*").eq("id", params.id).eq("user_id", userId).single();
           if (error) return err(error.message);
           return ok({ chunk: data });
         }
         case "create": {
-          if (!params.label || !params.content) return err("Missing required: label, content");
+          if (!params.name || !params.content) return err("Missing required: name, content");
+          const chunkName = String(params.name).slice(0, 30);
           const chunkId = crypto.randomUUID();
+
+          // Get current max order to append at end
+          const { data: existing } = await supabase
+            .from("prompt_chunks")
+            .select("order")
+            .eq("user_id", userId);
+          const maxOrder = existing && existing.length > 0
+            ? Math.max(...existing.map((c: any) => c.order ?? 0))
+            : -1;
+
           const { data, error } = await supabase.from("prompt_chunks").insert({
             id: chunkId,
             user_id: userId,
-            label: params.label,
+            name: chunkName,
             content: params.content,
-            agent_id: (params.agent_id as string) || null,
-            enabled: true,
-            sort_order: (params.sort_order as number) || 0,
+            color: (params.color as string) || "#6B7280",
+            category: (params.category as string) || "Uncategorized",
+            order: (params.order as number) ?? maxOrder + 1,
           }).select().single();
           if (error) return err(error.message);
-          api.logger?.info?.(`[ofiere] Prompt chunk created: "${params.label}" by agent`);
-          return ok({ message: `Prompt chunk "${params.label}" created`, chunk: data });
+          api.logger?.info?.(`[ofiere] Prompt chunk created: "${chunkName}" by agent`);
+          return ok({ message: `Prompt chunk "${chunkName}" created`, chunk: data });
         }
         case "update": {
           if (!params.id) return err("Missing required: id");
           const upd: Record<string, any> = { updated_at: new Date().toISOString() };
-          for (const f of ["label", "content", "enabled", "sort_order", "agent_id"]) {
+          for (const f of ["name", "content", "color", "category", "order"]) {
             if ((params as any)[f] !== undefined) upd[f] = (params as any)[f];
           }
-          const { error } = await supabase.from("prompt_chunks").update(upd).eq("id", params.id);
+          if (upd.name) upd.name = String(upd.name).slice(0, 30);
+          const { data, error } = await supabase.from("prompt_chunks").update(upd).eq("id", params.id).eq("user_id", userId).select().single();
           if (error) return err(error.message);
           api.logger?.info?.(`[ofiere] Prompt chunk ${params.id} updated by agent`);
-          return ok({ message: "Prompt chunk updated", ok: true });
+          return ok({ message: "Prompt chunk updated", chunk: data });
         }
         case "delete": {
           if (!params.id) return err("Missing required: id");
-          const { error } = await supabase.from("prompt_chunks").delete().eq("id", params.id);
+          const { error } = await supabase.from("prompt_chunks").delete().eq("id", params.id).eq("user_id", userId);
           if (error) return err(error.message);
           api.logger?.info?.(`[ofiere] Prompt chunk ${params.id} deleted by agent`);
           return ok({ message: "Prompt chunk deleted", ok: true });