ofiere-openclaw-plugin 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# 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.
+
+## Install
+
+```bash
+openclaw plugins install @ofiere-ai/openclaw-plugin
+```
+
+Or install from the local repo (for development):
+
+```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:
+
+```bash
+openclaw ofiere setup
+```
+
+Then restart the gateway:
+
+```bash
+openclaw gateway restart
+```
+
+## 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.
+
+Changes made by the agent are immediately visible on the Ofiere dashboard (Vercel) via Supabase real-time subscriptions.
+
+## AI Tools
+
+| Tool | Description |
+|---|---|
+| `OFIERE_LIST_TASKS` | List and filter PM tasks |
+| `OFIERE_CREATE_TASK` | Create a new task (auto-assigns to calling agent) |
+| `OFIERE_UPDATE_TASK` | Update task fields (status, priority, progress, etc.) |
+| `OFIERE_DELETE_TASK` | Delete a task and its subtasks |
+| `OFIERE_LIST_AGENTS` | List available agents for task assignment |
+
+## CLI Commands
+
+```bash
+openclaw ofiere setup     # Configure Supabase connection and agent identity
+openclaw ofiere status    # View current configuration
+openclaw ofiere doctor    # Test connection and list agents
+```
+
+## Configuration
+
+Set via `openclaw ofiere setup` or environment variables:
+
+| Option | Env Var | Description |
+|---|---|---|
+| `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`) |
+| `enabled` | — | Enable/disable the plugin (default: `true`) |
+
+## Architecture
+
+```
+OpenClaw Agent (VPS)
+     │ plugin runs IN-PROCESS
+Ofiere Plugin ──► Supabase (shared database)
+                      ▲
+Ofiere Dashboard ─────┘  (Vercel, real-time)
+```
+
+Both the agent plugin and the Vercel dashboard talk to the same Supabase instance. When the agent creates/updates a task, the dashboard sees it instantly through Supabase real-time subscriptions.
+
+## Links
+
+- [Ofiere Dashboard](https://github.com/gilanggemar/Ofiere)
+- [OpenClaw](https://openclaw.ai)
+- [Supabase](https://supabase.com)

package/index.ts

@@ -0,0 +1,92 @@
+// index.ts — Ofiere PM Plugin for OpenClaw
+// Uses definePluginEntry from the official plugin-entry subpath (NOT the deprecated monolithic root)
+// Pattern: https://docs.openclaw.ai/plugins/building-plugins#quick-start-tool-plugin
+
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { parseOfiereConfig } from "./src/config.js";
+import { getSupabase } from "./src/supabase.js";
+import { registerTools } from "./src/tools.js";
+import { getSystemPrompt } from "./src/prompt.js";
+import { registerCli } from "./src/cli.js";
+import { seedAgentCache } from "./src/agent-resolver.js";
+
+export default definePluginEntry({
+  id: "ofiere",
+  name: "Ofiere PM",
+  description:
+    "Manage Ofiere PM tasks, agents, and projects directly from the agent. " +
+    "Create tasks, update progress, assign agents — all synced to the dashboard in real time.",
+
+  register(api) {
+    const config = parseOfiereConfig(api.pluginConfig);
+
+    // Always register CLI (even if disabled — so user can run `openclaw ofiere setup`)
+    registerCli(api);
+
+    if (!config.enabled) {
+      api.logger.debug("[ofiere] Plugin disabled via config");
+      return;
+    }
+
+    if (!config.supabaseUrl || !config.serviceRoleKey) {
+      api.logger.warn(
+        "[ofiere] Not configured. Run: openclaw ofiere setup",
+      );
+      return;
+    }
+
+    if (!config.userId) {
+      api.logger.warn(
+        "[ofiere] Missing userId. Run: openclaw ofiere setup",
+      );
+      return;
+    }
+
+    // ── Pre-seed agent cache if OFIERE_AGENT_ID is set (legacy mode) ──────
+    if (config.agentId) {
+      // Try to extract the calling agent's name from OpenClaw context
+      const callerName =
+        (api as any)?.agentContext?.accountId ||
+        (api as any)?.agentContext?.name ||
+        (api as any)?.currentAgent?.accountId ||
+        "";
+      if (callerName) {
+        seedAgentCache(callerName, config.userId, config.agentId);
+      }
+    }
+
+    // ── State for system prompt injection ──────────────────────────────────
+    const promptState = {
+      toolCount: 0,
+      agentId: config.agentId,
+      connectError: "",
+      ready: false,
+    };
+
+    // ── Hook: inject Ofiere context into every agent prompt ────────────────
+    // Uses api.registerHook (the documented API) instead of api.on shorthand
+    api.registerHook(
+      ["before_prompt_build"],
+      () => ({
+        prependSystemContext: getSystemPrompt(promptState),
+      }),
+    );
+
+    // ── Connect to Supabase and register tools ────────────────────────────
+    try {
+      const supabase = getSupabase(config.supabaseUrl, config.serviceRoleKey);
+      registerTools(api, supabase, config);
+      promptState.toolCount = 5;
+      promptState.ready = true;
+      const agentLabel = config.agentId || "auto-detect";
+      api.logger.info(
+        `[ofiere] Ready — 5 tools registered (agent: ${agentLabel})`,
+      );
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      promptState.connectError = msg;
+      promptState.ready = true;
+      api.logger.error(`[ofiere] Failed to initialize: ${msg}`);
+    }
+  },
+});

package/openclaw.plugin.json

@@ -0,0 +1,54 @@
+{
+  "id": "ofiere",
+  "name": "Ofiere PM",
+  "description": "Manage Ofiere PM tasks, agents, and projects directly from the agent. The agent can create tasks, update progress, list work items, and more — all synced to the Ofiere dashboard in real time.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": {
+        "type": "boolean",
+        "description": "Enable or disable the Ofiere PM integration"
+      },
+      "supabaseUrl": {
+        "type": "string",
+        "description": "Your Supabase project URL (e.g. https://xxx.supabase.co)"
+      },
+      "serviceRoleKey": {
+        "type": "string",
+        "description": "Supabase service role key for full database access"
+      },
+      "userId": {
+        "type": "string",
+        "description": "Your Ofiere user ID (UUID from auth.users)"
+      },
+      "agentId": {
+        "type": "string",
+        "description": "This agent's ID in Ofiere (e.g. 'sasha', 'ivy', 'thalia')"
+      }
+    }
+  },
+  "uiHints": {
+    "enabled": {
+      "label": "Enable Ofiere PM",
+      "help": "Enable or disable the Ofiere PM integration"
+    },
+    "supabaseUrl": {
+      "label": "Supabase URL",
+      "help": "Your Supabase project URL"
+    },
+    "serviceRoleKey": {
+      "label": "Service Role Key",
+      "help": "Supabase service role key (keep secret!)",
+      "sensitive": true
+    },
+    "userId": {
+      "label": "User ID",
+      "help": "Your user UUID from the Ofiere dashboard"
+    },
+    "agentId": {
+      "label": "Agent ID",
+      "help": "This agent's ID (e.g. 'sasha')"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "ofiere-openclaw-plugin",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "OpenClaw plugin for Ofiere PM — manage tasks, agents, and projects from your agent",
+  "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],
+  "homepage": "https://github.com/gilanggemar/Ofiere",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gilanggemar/Ofiere.git"
+  },
+  "license": "MIT",
+  "files": [
+    "index.ts",
+    "src",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.24-beta.2",
+      "minGatewayVersion": "2026.3.24-beta.2"
+    },
+    "build": {
+      "openclawVersion": "2026.3.24-beta.2",
+      "pluginSdkVersion": "2026.3.24-beta.2"
+    }
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.98.0",
+    "zod": "^3.25.11"
+  }
+}

package/src/agent-resolver.ts

@@ -0,0 +1,104 @@
+// src/agent-resolver.ts — Dynamic agent identity resolution
+// Resolves an OpenClaw account name (e.g. "ivy") to a Ofiere agent UUID.
+// Caches lookups so only the first call per agent hits Supabase.
+// Auto-registers unknown agents so multi-agent setups work out of the box.
+
+import type { SupabaseClient } from "@supabase/supabase-js";
+
+const cache = new Map<string, string>();
+
+/**
+ * Resolves an OpenClaw accountId to a Ofiere agent UUID.
+ *
+ * Strategy:
+ *   1. Check in-memory cache
+ *   2. Look up by name (case-insensitive) in agents table
+ *   3. If not found, auto-register a new agent record
+ *   4. Cache the result for subsequent calls
+ *
+ * @param accountId - The OpenClaw account name (e.g. "ivy", "daisy")
+ * @param userId    - The Ofiere user UUID who owns this agent
+ * @param supabase  - Supabase client
+ * @returns The Ofiere agent UUID
+ */
+export async function resolveAgentId(
+  accountId: string,
+  userId: string,
+  supabase: SupabaseClient,
+): Promise<string> {
+  if (!accountId) return "";
+
+  const cacheKey = `${userId}:${accountId}`;
+
+  // 1. Cache hit
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey)!;
+  }
+
+  // 2. Look up by name (case-insensitive)
+  const { data: existing } = await supabase
+    .from("agents")
+    .select("id")
+    .eq("user_id", userId)
+    .ilike("name", accountId)
+    .limit(1)
+    .single();
+
+  if (existing?.id) {
+    cache.set(cacheKey, existing.id);
+    return existing.id;
+  }
+
+  // 3. Also try matching by codename
+  const { data: byCodename } = await supabase
+    .from("agents")
+    .select("id")
+    .eq("user_id", userId)
+    .ilike("codename", accountId)
+    .limit(1)
+    .single();
+
+  if (byCodename?.id) {
+    cache.set(cacheKey, byCodename.id);
+    return byCodename.id;
+  }
+
+  // 4. Auto-register a new agent
+  const newId = `agent-${accountId.toLowerCase()}-${Date.now()}`;
+  const { data: created } = await supabase
+    .from("agents")
+    .insert({
+      id: newId,
+      user_id: userId,
+      name: accountId.charAt(0).toUpperCase() + accountId.slice(1).toLowerCase(),
+      codename: accountId.toLowerCase(),
+      status: "active",
+      role: "operative",
+      level: 1,
+      xp: 0,
+      created_at: new Date().toISOString(),
+    })
+    .select("id")
+    .single();
+
+  const resolvedId = created?.id || newId;
+  cache.set(cacheKey, resolvedId);
+  return resolvedId;
+}
+
+/**
+ * Pre-warm the cache with a known mapping.
+ * Used when OFIERE_AGENT_ID env var is set (legacy single-agent mode).
+ */
+export function seedAgentCache(accountId: string, userId: string, agentId: string): void {
+  if (accountId && agentId) {
+    cache.set(`${userId}:${accountId}`, agentId);
+  }
+}
+
+/**
+ * Clear the cache (useful for testing).
+ */
+export function clearAgentCache(): void {
+  cache.clear();
+}

package/src/cli.ts

@@ -0,0 +1,247 @@
+// src/cli.ts — CLI registration for Ofiere PM plugin
+// Uses api.registerCli with descriptors as documented:
+//   https://docs.openclaw.ai/plugins/sdk-overview#cli-registration-metadata
+//
+// The descriptors array enables lazy plugin CLI registration and root help text.
+// The async ({ program }) => {} pattern is shown in the official Matrix plugin example.
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { createClient } from "@supabase/supabase-js";
+
+// ── Config paths ─────────────────────────────────────────────────────────────
+
+/** Auto-detect OpenClaw home for env file */
+function getOpenClawHome(): string {
+  if (fs.existsSync("/data/.openclaw")) return "/data/.openclaw";
+  return path.join(os.homedir(), ".openclaw");
+}
+
+function getEnvFile(): string {
+  return path.join(getOpenClawHome(), ".env");
+}
+
+/** Read env vars from the .env file */
+function readEnvFile(): Record<string, string> {
+  const envPath = getEnvFile();
+  const result: Record<string, string> = {};
+  try {
+    const content = fs.readFileSync(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const match = line.match(/^([^#=]+)=(.*)$/);
+      if (match) {
+        result[match[1].trim()] = match[2].trim();
+      }
+    }
+  } catch { /* file doesn't exist yet */ }
+  return result;
+}
+
+/** Append or update env vars in the .env file (idempotent) */
+function setEnvVars(vars: Record<string, string>): void {
+  const envPath = getEnvFile();
+  const dir = path.dirname(envPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  let content = "";
+  try {
+    content = fs.readFileSync(envPath, "utf-8");
+  } catch { /* file doesn't exist yet */ }
+
+  for (const [key, value] of Object.entries(vars)) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    } else {
+      content = content.trimEnd() + `\n${key}=${value}`;
+    }
+  }
+
+  fs.writeFileSync(envPath, content.trim() + "\n");
+}
+
+function getPluginConfig(): {
+  supabaseUrl?: string;
+  serviceRoleKey?: string;
+  userId?: string;
+  agentId?: string;
+  enabled?: boolean;
+} {
+  const env = readEnvFile();
+  return {
+    supabaseUrl: process.env.OFIERE_SUPABASE_URL || env.OFIERE_SUPABASE_URL || undefined,
+    serviceRoleKey: process.env.OFIERE_SERVICE_ROLE_KEY || env.OFIERE_SERVICE_ROLE_KEY || undefined,
+    userId: process.env.OFIERE_USER_ID || env.OFIERE_USER_ID || undefined,
+    agentId: process.env.OFIERE_AGENT_ID || env.OFIERE_AGENT_ID || undefined,
+    enabled: true,
+  };
+}
+
+function ask(rl: readline.Interface, question: string): Promise<string> {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+// ── CLI Registration ─────────────────────────────────────────────────────────
+
+export function registerCli(api: any): void {
+  api.registerCli(
+    // Async registrar — follows the pattern from the official Matrix plugin example
+    async ({ program }: { program: any }) => {
+      const cmd = program
+        .command("ofiere")
+        .description("Ofiere PM dashboard integration");
+
+      // ── setup ──────────────────────────────────────────────────────────
+      cmd
+        .command("setup")
+        .description("Configure Ofiere PM connection (writes to .env, never touches openclaw.json)")
+        .option("--supabase-url <url>", "Supabase project URL")
+        .option("--service-key <key>", "Supabase service role key")
+        .option("--user-id <id>", "Ofiere user UUID")
+        .action(async (opts: {
+          supabaseUrl?: string;
+          serviceKey?: string;
+          userId?: string;
+        }) => {
+          let supabaseUrl = opts.supabaseUrl?.trim();
+          let serviceKey = opts.serviceKey?.trim();
+          let userId = opts.userId?.trim();
+
+          // Interactive mode if any field is missing
+          if (!supabaseUrl || !serviceKey || !userId) {
+            console.log("\nOfiere PM Setup\n");
+            const rl = readline.createInterface({
+              input: process.stdin,
+              output: process.stdout,
+            });
+
+            if (!supabaseUrl) {
+              supabaseUrl = (await ask(rl, "Supabase URL (https://xxx.supabase.co): ")).trim();
+            }
+            if (!serviceKey) {
+              serviceKey = (await ask(rl, "Service role key: ")).trim();
+            }
+            if (!userId) {
+              userId = (await ask(rl, "User ID (UUID): ")).trim();
+            }
+
+            rl.close();
+          }
+
+          if (!supabaseUrl || !serviceKey || !userId) {
+            console.log("\nAll fields are required. Setup cancelled.");
+            return;
+          }
+
+          // Write to .env file (NEVER touches openclaw.json)
+          setEnvVars({
+            OFIERE_SUPABASE_URL: supabaseUrl,
+            OFIERE_SERVICE_ROLE_KEY: serviceKey,
+            OFIERE_USER_ID: userId,
+          });
+
+          const envFile = getEnvFile();
+          console.log(`\nDone. Saved to ${envFile}`);
+          console.log(`  Supabase URL: ${supabaseUrl}`);
+          console.log(`  User ID:      ${userId}`);
+          console.log(`  Plugin:       enabled (global — all agents)`);
+          console.log("\nRestart to apply: openclaw gateway restart\n");
+        });
+
+      // ── status ─────────────────────────────────────────────────────────
+      cmd
+        .command("status")
+        .description("Show Ofiere PM plugin configuration")
+        .action(async () => {
+          const cfg = getPluginConfig();
+          console.log("\nOfiere PM Status\n");
+
+          if (!cfg.supabaseUrl) {
+            console.log("  Not configured. Run: openclaw ofiere setup\n");
+            return;
+          }
+
+          const maskedKey = cfg.serviceRoleKey
+            ? `${cfg.serviceRoleKey.slice(0, 10)}...${cfg.serviceRoleKey.slice(-4)}`
+            : "not set";
+
+          console.log(`  Supabase URL:    ${cfg.supabaseUrl}`);
+          console.log(`  Service Key:     ${maskedKey}`);
+          console.log(`  User ID:         ${cfg.userId || "not set"}`);
+          console.log(`  Agent ID:        ${cfg.agentId || "(auto-detect — all agents)"}`);
+          console.log(`  Config Source:    ${getEnvFile()}`);
+          console.log("");
+        });
+
+      // ── doctor ─────────────────────────────────────────────────────────
+      cmd
+        .command("doctor")
+        .description("Test Ofiere PM connection")
+        .action(async () => {
+          const cfg = getPluginConfig();
+          console.log("\nOfiere PM Doctor\n");
+
+          if (!cfg.supabaseUrl || !cfg.serviceRoleKey || !cfg.userId) {
+            console.log("  Not configured. Run: openclaw ofiere setup\n");
+            return;
+          }
+
+          console.log(`  Supabase URL:  ${cfg.supabaseUrl}`);
+          console.log(`  Agent Mode:    ${cfg.agentId ? `fixed (${cfg.agentId})` : "auto-detect (all agents)"}`);
+          console.log("\n  Testing connection...");
+
+          try {
+            const sb = createClient(cfg.supabaseUrl, cfg.serviceRoleKey, {
+              auth: { persistSession: false },
+            });
+
+            const { data, error } = await sb
+              .from("agents")
+              .select("id, name, status")
+              .eq("user_id", cfg.userId)
+              .order("name");
+
+            if (error) {
+              console.log(`\n  ✗ Connection failed: ${error.message}\n`);
+              return;
+            }
+
+            console.log(`  ✓ Found ${(data || []).length} agents\n`);
+            for (const agent of data || []) {
+              const marker = agent.id === cfg.agentId ? " ← PINNED" : "";
+              console.log(`    ${agent.id} — ${agent.name} (${agent.status})${marker}`);
+            }
+
+            const { count } = await sb
+              .from("tasks")
+              .select("id", { count: "exact", head: true })
+              .eq("user_id", cfg.userId);
+
+            console.log(`\n  Tasks accessible: ${count ?? 0}`);
+            console.log("\n  Status: healthy ✓\n");
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.log(`\n  ✗ Connection failed: ${msg}`);
+            console.log("\n  Possible causes:");
+            console.log("    - Invalid Supabase URL or service key");
+            console.log("    - Network issue reaching Supabase");
+            console.log("    - Invalid user ID\n");
+          }
+        });
+    },
+    // Descriptors enable lazy registration and root help text
+    {
+      descriptors: [
+        {
+          name: "ofiere",
+          description: "Manage Ofiere PM dashboard integration (setup, status, diagnostics)",
+          hasSubcommands: true,
+        },
+      ],
+    },
+  );
+}

package/src/config.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import type { OfiereConfig } from "./types.js";
+
+export const OfiereConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  supabaseUrl: z.string().default(""),
+  serviceRoleKey: z.string().default(""),
+  userId: z.string().default(""),
+  agentId: z.string().default(""),
+});
+
+export function parseOfiereConfig(value: unknown): OfiereConfig {
+  const raw =
+    value && typeof value === "object" && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : {};
+
+  const configObj = raw.config as Record<string, unknown> | undefined;
+
+  // Support both nested (config.supabaseUrl) and flat (supabaseUrl) access
+  // Also fall back to env vars
+  const supabaseUrl =
+    (typeof configObj?.supabaseUrl === "string" && configObj.supabaseUrl.trim()) ||
+    (typeof raw.supabaseUrl === "string" && raw.supabaseUrl.trim()) ||
+    process.env.OFIERE_SUPABASE_URL ||
+    process.env.SUPABASE_URL ||
+    "";
+
+  const serviceRoleKey =
+    (typeof configObj?.serviceRoleKey === "string" && configObj.serviceRoleKey.trim()) ||
+    (typeof raw.serviceRoleKey === "string" && raw.serviceRoleKey.trim()) ||
+    process.env.OFIERE_SERVICE_ROLE_KEY ||
+    process.env.SUPABASE_SERVICE_ROLE_KEY ||
+    "";
+
+  const userId =
+    (typeof configObj?.userId === "string" && configObj.userId.trim()) ||
+    (typeof raw.userId === "string" && raw.userId.trim()) ||
+    process.env.OFIERE_USER_ID ||
+    "";
+
+  const agentId =
+    (typeof configObj?.agentId === "string" && configObj.agentId.trim()) ||
+    (typeof raw.agentId === "string" && raw.agentId.trim()) ||
+    process.env.OFIERE_AGENT_ID ||
+    "";
+
+  return OfiereConfigSchema.parse({
+    ...raw,
+    supabaseUrl,
+    serviceRoleKey,
+    userId,
+    agentId,
+  });
+}

package/src/prompt.ts

@@ -0,0 +1,96 @@
+export function getSystemPrompt(state: {
+  ready: boolean;
+  toolCount: number;
+  agentId: string;
+  connectError: string;
+}): string {
+  if (state.ready && state.toolCount > 0) {
+    const agentLine = state.agentId
+      ? `Your agent ID is "${state.agentId}". You are registered in the Ofiere system.`
+      : `Your agent identity will be auto-detected at runtime. When you call any OFIERE tool, the system knows who you are.`;
+
+    const assignRule = state.agentId
+      ? `When you create a task without specifying agent_id, it is assigned to YOU (${state.agentId}).`
+      : `When you create a task without specifying agent_id, it is assigned to YOU automatically.`;
+
+    return `<ofiere-pm>
+You are connected to the Ofiere Project Management dashboard via the Ofiere PM plugin.
+${agentLine}
+
+## Your Ofiere PM Capabilities
+You have ${state.toolCount} tools to manage the PM dashboard:
+
+- **OFIERE_LIST_TASKS** — List and filter tasks from the PM dashboard
+- **OFIERE_CREATE_TASK** — Create new tasks (auto-assigned to you if no agent_id given)
+- **OFIERE_UPDATE_TASK** — Update task status, priority, progress, etc.
+- **OFIERE_DELETE_TASK** — Delete tasks
+- **OFIERE_LIST_AGENTS** — See all available agents for task assignment
+
+## Rules
+- ${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_LIST_AGENTS to find the agent ID, then pass it as agent_id.
+- Always confirm task creation/updates by reporting back what was done.
+- Task statuses are: PENDING, IN_PROGRESS, DONE, FAILED.
+- Priority levels: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL.
+- Changes you make appear in the Ofiere dashboard immediately in real time.
+- Do NOT fabricate task IDs — always use OFIERE_LIST_TASKS to look up real IDs.
+</ofiere-pm>`;
+  }
+
+  if (state.ready) {
+    const diagnostic = diagnoseError(state.connectError);
+    return `<ofiere-pm>
+The Ofiere PM plugin failed to connect.${state.connectError ? ` Error: ${state.connectError}` : ""}
+
+Diagnosis: ${diagnostic.reason}
+
+When the user asks about task management or the Ofiere dashboard, respond with:
+"${diagnostic.userMessage}"
+
+Do NOT pretend Ofiere tools exist or hallucinate tool calls. You have zero Ofiere tools available.
+</ofiere-pm>`;
+  }
+
+  return `<ofiere-pm>
+The Ofiere PM plugin is loading. Tools should be available shortly.
+If the user asks about tasks right now, ask them to wait a moment.
+</ofiere-pm>`;
+}
+
+function diagnoseError(error: string): { reason: string; userMessage: string } {
+  const lower = error.toLowerCase();
+
+  if (!error) {
+    return {
+      reason: "Connected but no tools were registered.",
+      userMessage:
+        "The Ofiere PM plugin connected but could not register tools. " +
+        "Run `openclaw ofiere doctor` to diagnose.",
+    };
+  }
+
+  if (lower.includes("supabase") || lower.includes("url") || lower.includes("key")) {
+    return {
+      reason: "Supabase connection configuration issue.",
+      userMessage:
+        "The Ofiere PM plugin could not connect to Supabase. " +
+        "Check your configuration with `openclaw ofiere status` and re-run " +
+        "`openclaw ofiere setup` if needed, then `openclaw gateway restart`.",
+    };
+  }
+
+  if (lower.includes("user_id") || lower.includes("userid")) {
+    return {
+      reason: "Missing or invalid user ID in configuration.",
+      userMessage:
+        "The Ofiere PM plugin needs a valid user ID. " +
+        "Run `openclaw ofiere setup` with your user UUID, then `openclaw gateway restart`.",
+    };
+  }
+
+  return {
+    reason: `Unexpected error: ${error}`,
+    userMessage: `The Ofiere PM plugin encountered an error: ${error}. Run \`openclaw ofiere doctor\` for details.`,
+  };
+}

package/src/supabase.ts

@@ -0,0 +1,13 @@
+import { createClient, type SupabaseClient } from "@supabase/supabase-js";
+
+let _client: SupabaseClient | null = null;
+
+export function getSupabase(supabaseUrl: string, serviceRoleKey: string): SupabaseClient {
+  if (_client) return _client;
+
+  _client = createClient(supabaseUrl, serviceRoleKey, {
+    auth: { persistSession: false },
+  });
+
+  return _client;
+}

package/src/tools.ts

@@ -0,0 +1,403 @@
+// src/tools.ts — Tool registration for Ofiere PM plugin
+// Uses api.registerTool(tool, opts?) as documented:
+//   https://docs.openclaw.ai/plugins/sdk-overview#tools-and-commands
+//   https://docs.openclaw.ai/plugins/building-plugins#registering-agent-tools
+//
+// - Required tools: always available (no opts)
+// - Optional tools: { optional: true } — user must allowlist or allowlist the plugin id
+
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { OfiereConfig } from "./types.js";
+import { resolveAgentId } from "./agent-resolver.js";
+
+// ─── Tool result shape (matches OpenClaw SDK) ────────────────────────────────
+
+interface ToolResult {
+  content: Array<{ type: "text"; text: string }>;
+}
+
+function ok(data: unknown): ToolResult {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+  };
+}
+
+function err(message: string): ToolResult {
+  return {
+    content: [{ type: "text" as const, text: `Error: ${message}` }],
+  };
+}
+
+// ─── Helper: extract calling agent's accountId from OpenClaw context ─────────
+
+function getCallingAgentName(api: any): string {
+  // OpenClaw passes agent context in various ways — try all known paths
+  try {
+    return (
+      api?.agentContext?.accountId ||
+      api?.agentContext?.name ||
+      api?.currentAgent?.accountId ||
+      api?.currentAgent?.name ||
+      ""
+    );
+  } catch {
+    return "";
+  }
+}
+
+// ─── Tool Registration ───────────────────────────────────────────────────────
+
+export function registerTools(
+  api: any, // OpenClawPluginApi — typed as any to avoid import-path issues at install time
+  supabase: SupabaseClient,
+  config: OfiereConfig,
+): void {
+  const userId = config.userId;
+  const fallbackAgentId = config.agentId; // May be empty — that's fine
+
+  /**
+   * Resolve the agent ID for the calling agent.
+   * Priority: explicit param > runtime context > env var fallback
+   */
+  async function resolveAgent(explicitId?: string): Promise<string | null> {
+    // 1. Explicit agent_id passed by the LLM (e.g. "create task for Daisy")
+    if (explicitId && explicitId.trim()) return explicitId.trim();
+
+    // 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 to env var
+      }
+    }
+
+    // 3. Env var fallback (OFIERE_AGENT_ID — legacy single-agent mode)
+    return fallbackAgentId || null;
+  }
+
+  // ── OFIERE_LIST_TASKS — Required (read-only, no side effects) ────────
+
+  api.registerTool({
+    name: "OFIERE_LIST_TASKS",
+    label: "List Ofiere Tasks",
+    description:
+      "List tasks from the Ofiere PM dashboard. " +
+      "Optionally filter by space_id, folder_id, agent_id, or status. " +
+      "Returns an array of task objects with their details.",
+    parameters: {
+      type: "object",
+      properties: {
+        space_id: { type: "string", description: "Filter by PM space ID" },
+        folder_id: { type: "string", description: "Filter by PM folder ID" },
+        agent_id: { type: "string", description: "Filter by assigned agent ID" },
+        status: {
+          type: "string",
+          description: "Filter by status: PENDING, IN_PROGRESS, DONE, FAILED",
+          enum: ["PENDING", "IN_PROGRESS", "DONE", "FAILED"],
+        },
+        limit: { type: "number", description: "Max results (default 50)" },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      try {
+        let query = supabase
+          .from("tasks")
+          .select(
+            "id, title, description, status, priority, agent_id, space_id, folder_id, " +
+            "start_date, due_date, progress, created_at, updated_at",
+          )
+          .eq("user_id", userId)
+          .order("updated_at", { ascending: false });
+
+        if (params.space_id) query = query.eq("space_id", params.space_id as string);
+        if (params.folder_id) query = query.eq("folder_id", params.folder_id as string);
+        if (params.agent_id) query = query.eq("agent_id", params.agent_id as string);
+        if (params.status) query = query.eq("status", params.status as string);
+        query = query.limit((params.limit as number) || 50);
+
+        const { data, error } = await query;
+        if (error) return err(error.message);
+        return ok({ tasks: data || [], count: (data || []).length });
+      } catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+      }
+    },
+  });
+
+  // ── OFIERE_CREATE_TASK — Optional (has side effects: writes to DB) ───
+
+  api.registerTool(
+    {
+      name: "OFIERE_CREATE_TASK",
+      label: "Create Ofiere Task",
+      description:
+        "Create a new task in the Ofiere PM dashboard. " +
+        "If agent_id is not provided, the task is automatically assigned to you (the calling agent). " +
+        "Pass agent_id as 'none' or 'unassigned' to create an unassigned task. " +
+        "The task will appear in the dashboard immediately via real-time sync.",
+      parameters: {
+        type: "object",
+        required: ["title"],
+        properties: {
+          title: { type: "string", description: "Task title (required)" },
+          description: { type: "string", description: "Task description" },
+          agent_id: {
+            type: "string",
+            description:
+              "Agent ID to assign the task to. If omitted, assigns to yourself. " +
+              "Pass 'none' or 'unassigned' to create a task with no assignee. " +
+              "Use OFIERE_LIST_AGENTS to see available agents.",
+          },
+          status: {
+            type: "string",
+            description: "Initial status (default: PENDING)",
+            enum: ["PENDING", "IN_PROGRESS", "DONE", "FAILED"],
+          },
+          priority: {
+            type: "number",
+            description: "Priority: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL (default: 1)",
+          },
+          space_id: { type: "string", description: "PM Space ID to place the task in" },
+          folder_id: { type: "string", description: "PM Folder ID to place the task in" },
+          start_date: { type: "string", description: "Start date (ISO 8601 format)" },
+          due_date: { type: "string", description: "Due date (ISO 8601 format)" },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for the task",
+          },
+        },
+      },
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!params.title) return err("Missing required field: title");
+
+          const id = `task-${Date.now()}`;
+          const now = new Date().toISOString();
+
+          // Handle explicit "none"/"unassigned"
+          const rawAgentId = params.agent_id as string | undefined;
+          const isUnassigned =
+            rawAgentId &&
+            ["none", "unassigned", "null", ""].includes(rawAgentId.toLowerCase().trim());
+
+          const assignee = isUnassigned ? null : await resolveAgent(rawAgentId);
+
+          const insertData: Record<string, unknown> = {
+            id,
+            user_id: userId,
+            title: params.title,
+            description: (params.description as string) || null,
+            agent_id: assignee,
+            assignee_type: "agent",
+            status: (params.status as string) || "PENDING",
+            priority: params.priority !== undefined ? params.priority : 1,
+            space_id: (params.space_id as string) || null,
+            folder_id: (params.folder_id as string) || null,
+            start_date: (params.start_date as string) || null,
+            due_date: (params.due_date as string) || null,
+            tags: (params.tags as string[]) || [],
+            progress: 0,
+            sort_order: 0,
+            custom_fields: {},
+            created_at: now,
+            updated_at: now,
+          };
+
+          const { error } = await supabase.from("tasks").insert(insertData);
+
+          if (error) {
+            if (error.message?.includes("agent_id") || error.message?.includes("foreign key")) {
+              insertData.agent_id = null;
+              const retry = await supabase.from("tasks").insert(insertData);
+              if (retry.error) return err(retry.error.message);
+              return ok({
+                id,
+                message: `Task "${params.title}" created (agent_id "${assignee}" was invalid, assigned to none)`,
+                task: insertData,
+              });
+            }
+            return err(error.message);
+          }
+
+          return ok({
+            id,
+            message: `Task "${params.title}" created and assigned to ${assignee || "no one"}`,
+            task: insertData,
+          });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : String(e));
+        }
+      },
+    },
+    { optional: true },
+  );
+
+  // ── OFIERE_UPDATE_TASK — Optional (has side effects) ─────────────────
+
+  api.registerTool(
+    {
+      name: "OFIERE_UPDATE_TASK",
+      label: "Update Ofiere Task",
+      description:
+        "Update an existing task in the Ofiere PM dashboard. Only provided fields are changed. " +
+        "Changes appear in the dashboard immediately via real-time sync.",
+      parameters: {
+        type: "object",
+        required: ["task_id"],
+        properties: {
+          task_id: { type: "string", description: "The task ID to update (required)" },
+          title: { type: "string", description: "New title" },
+          description: { type: "string", description: "New description" },
+          status: {
+            type: "string",
+            description: "New status",
+            enum: ["PENDING", "IN_PROGRESS", "DONE", "FAILED"],
+          },
+          priority: { type: "number", description: "New priority (0-3)" },
+          progress: { type: "number", description: "Progress percentage (0-100)" },
+          agent_id: { type: "string", description: "Reassign to a different agent" },
+          start_date: { type: "string", description: "New start date (ISO 8601)" },
+          due_date: { type: "string", description: "New due date (ISO 8601)" },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "New tags",
+          },
+        },
+      },
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!params.task_id) return err("Missing required field: task_id");
+
+          const updates: Record<string, unknown> = { updated_at: new Date().toISOString() };
+          const fields = [
+            "title", "description", "status", "priority", "progress",
+            "agent_id", "start_date", "due_date", "tags",
+          ];
+          for (const f of fields) {
+            if (params[f] !== undefined) updates[f] = params[f];
+          }
+          if (params.status === "DONE") updates.completed_at = new Date().toISOString();
+
+          const { data, error } = await supabase
+            .from("tasks")
+            .update(updates)
+            .eq("id", params.task_id as string)
+            .eq("user_id", userId)
+            .select("id, title, status, priority, agent_id")
+            .single();
+
+          if (error) return err(error.message);
+          return ok({ message: `Task "${data?.title}" updated`, task: data });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : String(e));
+        }
+      },
+    },
+    { optional: true },
+  );
+
+  // ── OFIERE_DELETE_TASK — Optional (destructive side effect) ──────────
+
+  api.registerTool(
+    {
+      name: "OFIERE_DELETE_TASK",
+      label: "Delete Ofiere Task",
+      description:
+        "Delete a task from the Ofiere PM dashboard. Also removes subtasks and linked scheduler events.",
+      parameters: {
+        type: "object",
+        required: ["task_id"],
+        properties: {
+          task_id: { type: "string", description: "The task ID to delete (required)" },
+        },
+      },
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!params.task_id) return err("Missing required field: task_id");
+          const taskId = params.task_id as string;
+
+          await supabase.from("scheduler_events").delete().eq("task_id", taskId);
+
+          const { data: subtasks } = await supabase
+            .from("tasks")
+            .select("id")
+            .eq("parent_task_id", taskId)
+            .eq("user_id", userId);
+
+          if (subtasks && subtasks.length > 0) {
+            for (const sub of subtasks) {
+              await supabase.from("scheduler_events").delete().eq("task_id", sub.id);
+            }
+            await supabase
+              .from("tasks")
+              .delete()
+              .in("id", subtasks.map((s: { id: string }) => s.id))
+              .eq("user_id", userId);
+          }
+
+          const { error } = await supabase
+            .from("tasks")
+            .delete()
+            .eq("id", taskId)
+            .eq("user_id", userId);
+
+          if (error) return err(error.message);
+          return ok({ message: `Task ${taskId} deleted`, deleted: true });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : String(e));
+        }
+      },
+    },
+    { optional: true },
+  );
+
+  // ── OFIERE_LIST_AGENTS — Required (read-only, no side effects) ───────
+
+  api.registerTool({
+    name: "OFIERE_LIST_AGENTS",
+    label: "List Ofiere Agents",
+    description:
+      "List all available agents in the Ofiere system. " +
+      "Shows agent IDs, names, roles, and current status. " +
+      "Use this to find the right agent_id for task assignment.",
+    parameters: {
+      type: "object",
+      properties: {},
+    },
+    async execute(_id: string, _params: Record<string, unknown>) {
+      try {
+        // Resolve calling agent's ID for the "your_agent_id" hint
+        const callerName = getCallingAgentName(api);
+        let yourAgentId = fallbackAgentId || "";
+        if (callerName && !yourAgentId) {
+          try {
+            yourAgentId = await resolveAgentId(callerName, userId, supabase);
+          } catch { /* ignore */ }
+        }
+
+        const { data, error } = await supabase
+          .from("agents")
+          .select("id, name, codename, role, status")
+          .eq("user_id", userId)
+          .order("name");
+
+        if (error) return err(error.message);
+        return ok({
+          agents: data || [],
+          count: (data || []).length,
+          your_agent_id: yourAgentId,
+        });
+      } catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+      }
+    },
+  });
+
+  const callerName = getCallingAgentName(api);
+  const agentLabel = fallbackAgentId || callerName || "auto-detect";
+  api.logger.info(`[ofiere] 5 tools registered (agent: ${agentLabel})`);
+}

package/src/types.ts

@@ -0,0 +1,8 @@
+export interface OfiereConfig {
+  enabled: boolean;
+  supabaseUrl: string;
+  serviceRoleKey: string;
+  userId: string;
+  /** Optional — if not set, agent identity is resolved at runtime from OpenClaw context */
+  agentId: string;
+}