@knowsuchagency/fulcrum 2.8.2 → 2.10.0

package/README.md

@@ -15,7 +15,7 @@ Fulcrum doesn't replace your tools—it gives you leverage over them. You config
 **Six pillars:**
 
 - **Claude Code Ecosystem** — Deep integration with Claude Code. Connect via messaging channels, manage tasks, deploy from one dashboard.
-- **Proactive AI Concierge** — Your assistant monitors messages, tracks actionable events, creates daily plans, and sends morning/evening briefings automatically.
+- **Proactive AI Concierge** — Your assistant monitors messages, stores important observations as memories, creates daily plans, and sends morning/evening briefings automatically.
 - **Work From Anywhere** — Run Fulcrum on a remote server. Close your laptop, agents keep working.
 - **Project Management** — Tasks with dependencies, due dates, labels, and attachments. Visual kanban boards.
 - **Production Deployment** — Docker Compose with automatic Traefik routing and Cloudflare DNS/tunnels.
@@ -42,13 +42,13 @@ Fulcrum's AI assistant doesn't just respond—it actively monitors and manages y
 
 When messages arrive via Email, WhatsApp, Discord, Telegram, or Slack:
 
-- **Actionable requests** (deadlines, meetings, tasks) → Tracked as events, optionally creates tasks
+- **Actionable requests** (deadlines, meetings, tasks) → Stored as memories with `actionable` tag, optionally creates tasks
 - **Casual conversations** → Responded to naturally, no tracking overhead
 - **Spam/newsletters** → Silently ignored
 
-### Actionable Events
+### Persistent Memory
 
-Every important message becomes an **actionable event**—searchable, linkable to tasks, with a full decision audit trail. Your assistant remembers what it noticed and what it decided.
+Important observations are stored as **memories** with tags like `actionable` or `monitoring`—searchable via full-text search, with recency-weighted results so recent items surface first.
 
 ### Daily Planning
 
@@ -156,11 +156,13 @@ Create documents with live preview. Generate charts and visualizations. The assi
 
 ### Calendar Integration
 
-Connect your calendars via CalDAV so the AI assistant knows your schedule. Google Calendar is supported out of the box with OAuth2.
+Connect multiple calendar accounts via CalDAV so the AI assistant knows your schedule. Copy events between calendars across accounts.
 
+- **Multiple accounts** — Add as many CalDAV accounts as you need
 - **Google Calendar** — OAuth2 flow, no password needed
 - **Any CalDAV server** — Nextcloud, Radicale, Baikal, iCloud
-- **Automatic sync** — Calendars sync on a configurable interval
+- **Automatic sync** — Each account syncs independently on a configurable interval
+- **One-way event copying** — Copy events between calendars across accounts via configurable rules
 - **Assistant awareness** — The AI assistant uses your calendar context for planning and scheduling
 
 Enable in Settings → Calendar Integration.
@@ -247,7 +249,8 @@ Both plugins include an MCP server with 60+ tools:
 | **Backup & Restore** | Snapshot database and settings; auto-safety-backup on restore |
 | **Settings** | View and update configuration; manage notification channels |
 | **Memory** | Store and search persistent knowledge with FTS5 full-text search |
-| **Assistant Events** | Track actionable events; query decision history |
+| **Calendar** | Manage CalDAV accounts, sync calendars, configure event copy rules |
+| **Assistant** | Send messages via channels; query sweep history |
 
 Use `search_tools` to discover available tools by keyword or category.
 

package/bin/fulcrum.js

@@ -1197,6 +1197,13 @@ class FulcrumClient {
       method: "DELETE"
     });
   }
+  async deleteTag(tagName) {
+    const allTags = await this.fetch("/api/tags");
+    const tag = allTags.find((t2) => t2.name === tagName);
+    if (!tag)
+      throw new ApiError(404, "Tag not found");
+    return this.fetch(`/api/tags/${tag.id}`, { method: "DELETE" });
+  }
   async setTaskDueDate(taskId, dueDate) {
     return this.fetch(`/api/tasks/${taskId}/due-date`, {
       method: "PATCH",
@@ -1487,39 +1494,6 @@ class FulcrumClient {
       body: JSON.stringify({ uids, limit })
     });
   }
-  async listActionableEvents(options) {
-    const params = new URLSearchParams;
-    if (options?.status)
-      params.set("status", options.status);
-    if (options?.channel)
-      params.set("channel", options.channel);
-    if (options?.limit)
-      params.set("limit", String(options.limit));
-    if (options?.offset)
-      params.set("offset", String(options.offset));
-    const query = params.toString();
-    return this.fetch(`/api/assistant/events${query ? `?${query}` : ""}`);
-  }
-  async getActionableEvent(id) {
-    return this.fetch(`/api/assistant/events/${id}`);
-  }
-  async createActionableEvent(data) {
-    return this.fetch("/api/assistant/events", {
-      method: "POST",
-      body: JSON.stringify(data)
-    });
-  }
-  async updateActionableEvent(id, updates) {
-    return this.fetch(`/api/assistant/events/${id}`, {
-      method: "PATCH",
-      body: JSON.stringify(updates)
-    });
-  }
-  async deleteActionableEvent(id) {
-    return this.fetch(`/api/assistant/events/${id}`, {
-      method: "DELETE"
-    });
-  }
   async listSweepRuns(options) {
     const params = new URLSearchParams;
     if (options?.type)
@@ -1544,8 +1518,39 @@ class FulcrumClient {
   async getCaldavStatus() {
     return this.fetch("/api/caldav/status");
   }
-  async listCalendars() {
-    return this.fetch("/api/caldav/calendars");
+  async listCalendars(accountId) {
+    const params = accountId ? `?accountId=${accountId}` : "";
+    return this.fetch(`/api/caldav/calendars${params}`);
+  }
+  async listCaldavAccounts() {
+    return this.fetch("/api/caldav/accounts");
+  }
+  async createCaldavAccount(input) {
+    return this.fetch("/api/caldav/accounts", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async deleteCaldavAccount(id) {
+    return this.fetch(`/api/caldav/accounts/${id}`, { method: "DELETE" });
+  }
+  async syncCaldavAccount(id) {
+    return this.fetch(`/api/caldav/accounts/${id}/sync`, { method: "POST" });
+  }
+  async listCaldavCopyRules() {
+    return this.fetch("/api/caldav/copy-rules");
+  }
+  async createCaldavCopyRule(input) {
+    return this.fetch("/api/caldav/copy-rules", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async deleteCaldavCopyRule(id) {
+    return this.fetch(`/api/caldav/copy-rules/${id}`, { method: "DELETE" });
+  }
+  async executeCaldavCopyRule(id) {
+    return this.fetch(`/api/caldav/copy-rules/${id}/execute`, { method: "POST" });
   }
   async syncCalendars() {
     return this.fetch("/api/caldav/sync", { method: "POST" });
@@ -1611,9 +1616,6 @@ class FulcrumClient {
   async deleteMemory(id) {
     return this.fetch(`/api/memory/${id}`, { method: "DELETE" });
   }
-  async getAssistantStats() {
-    return this.fetch("/api/assistant/stats");
-  }
 }
 var init_client = __esm(() => {
   init_server();
@@ -43951,6 +43953,13 @@ var init_registry = __esm(() => {
       keywords: ["tags", "categories", "filter", "search", "discover"],
       defer_loading: false
     },
+    {
+      name: "delete_tag",
+      description: "Delete a tag from the database and all its associations",
+      category: "tasks",
+      keywords: ["tag", "delete", "remove", "cleanup"],
+      defer_loading: false
+    },
     {
       name: "list_task_attachments",
       description: "List all file attachments for a task",
@@ -44113,46 +44122,67 @@ var init_registry = __esm(() => {
       defer_loading: false
     },
     {
-      name: "create_actionable_event",
-      description: "Create an actionable event to track something noticed",
+      name: "get_last_sweep",
+      description: "Get information about the last sweep run of a type",
       category: "assistant",
-      keywords: ["event", "actionable", "track", "remember", "log", "decision", "memory"],
+      keywords: ["sweep", "last", "hourly", "morning", "evening", "ritual"],
       defer_loading: false
     },
     {
-      name: "list_actionable_events",
-      description: "List actionable events by status or channel",
-      category: "assistant",
-      keywords: ["event", "actionable", "list", "pending", "review", "memory"],
-      defer_loading: false
+      name: "list_caldav_accounts",
+      description: "List all CalDAV accounts configured for calendar sync",
+      category: "caldav",
+      keywords: ["caldav", "account", "list", "calendar", "google", "nextcloud"],
+      defer_loading: true
     },
     {
-      name: "get_actionable_event",
-      description: "Get details of a specific actionable event",
-      category: "assistant",
-      keywords: ["event", "actionable", "get", "details", "history"],
-      defer_loading: false
+      name: "create_caldav_account",
+      description: "Create a new CalDAV account with basic authentication",
+      category: "caldav",
+      keywords: ["caldav", "account", "create", "add", "calendar", "connect"],
+      defer_loading: true
     },
     {
-      name: "update_actionable_event",
-      description: "Update an actionable event status or link to a task",
-      category: "assistant",
-      keywords: ["event", "actionable", "update", "status", "link", "task", "log"],
-      defer_loading: false
+      name: "delete_caldav_account",
+      description: "Delete a CalDAV account and all its calendars and events",
+      category: "caldav",
+      keywords: ["caldav", "account", "delete", "remove", "disconnect"],
+      defer_loading: true
     },
     {
-      name: "get_assistant_stats",
-      description: "Get assistant statistics: event counts by status and last sweep times",
-      category: "assistant",
-      keywords: ["assistant", "stats", "statistics", "events", "sweep", "summary"],
-      defer_loading: false
+      name: "sync_caldav_account",
+      description: "Trigger a manual sync for a specific CalDAV account",
+      category: "caldav",
+      keywords: ["caldav", "account", "sync", "refresh", "calendar"],
+      defer_loading: true
     },
     {
-      name: "get_last_sweep",
-      description: "Get information about the last sweep run of a type",
-      category: "assistant",
-      keywords: ["sweep", "last", "hourly", "morning", "evening", "ritual"],
-      defer_loading: false
+      name: "list_caldav_copy_rules",
+      description: "List all CalDAV copy rules for one-way event replication between calendars",
+      category: "caldav",
+      keywords: ["caldav", "copy", "rule", "list", "replicate", "sync", "calendar"],
+      defer_loading: true
+    },
+    {
+      name: "create_caldav_copy_rule",
+      description: "Create a copy rule to replicate events from one calendar to another",
+      category: "caldav",
+      keywords: ["caldav", "copy", "rule", "create", "replicate", "calendar"],
+      defer_loading: true
+    },
+    {
+      name: "delete_caldav_copy_rule",
+      description: "Delete a CalDAV copy rule",
+      category: "caldav",
+      keywords: ["caldav", "copy", "rule", "delete", "remove"],
+      defer_loading: true
+    },
+    {
+      name: "execute_caldav_copy_rule",
+      description: "Manually execute a copy rule to replicate events now",
+      category: "caldav",
+      keywords: ["caldav", "copy", "rule", "execute", "run", "replicate"],
+      defer_loading: true
     },
     {
       name: "list_calendars",
@@ -44683,6 +44713,16 @@ var registerTaskTools = (server, client) => {
       return handleToolError(err);
     }
   });
+  server.tool("delete_tag", "Delete a tag from the database. This removes the tag and all its associations with tasks and projects.", {
+    tag: exports_external.string().describe("The exact name of the tag to delete")
+  }, async ({ tag }) => {
+    try {
+      await client.deleteTag(tag);
+      return formatSuccess({ deleted: tag });
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
   server.tool("list_tasks_by_due_date", "List tasks within a date range based on due date", {
     startDate: exports_external.optional(exports_external.string()).describe("Start date (YYYY-MM-DD), inclusive"),
     endDate: exports_external.optional(exports_external.string()).describe("End date (YYYY-MM-DD), inclusive"),
@@ -45615,8 +45655,8 @@ var init_email = __esm(() => {
   init_utils();
 });
 
-// cli/src/mcp/tools/assistant-events.ts
-var ActionableEventStatusSchema, ChannelSchema, registerAssistantEventTools = (server, client) => {
+// cli/src/mcp/tools/assistant.ts
+var ChannelSchema, registerAssistantTools = (server, client) => {
   server.tool("message", "Send a message to a messaging channel (email, WhatsApp, etc.). Use this to reply to messages or send proactive communications.", {
     channel: ChannelSchema.describe("Target channel: email, whatsapp, discord, telegram, slack, or all"),
     to: exports_external.string().describe("Recipient (email address, phone number, or channel ID)"),
@@ -45639,102 +45679,112 @@ var ActionableEventStatusSchema, ChannelSchema, registerAssistantEventTools = (s
       return handleToolError(err);
     }
   });
-  server.tool("create_actionable_event", "Create an actionable event to track something noticed (message, request, etc.). Use this to log decisions and maintain memory of things that need attention.", {
-    source_channel: ChannelSchema.exclude(["all"]).describe("Channel where the event originated"),
-    source_id: exports_external.string().describe("ID of the source message/email"),
-    source_metadata: exports_external.optional(exports_external.record(exports_external.string(), exports_external.any())).describe("Additional context (sender, subject, etc.)"),
-    summary: exports_external.optional(exports_external.string()).describe("AI-generated description of what this event is about"),
-    status: exports_external.optional(ActionableEventStatusSchema).describe("Event status (default: pending)"),
-    linked_task_id: exports_external.optional(exports_external.string()).describe("Fulcrum task ID if this event relates to a task")
-  }, async ({ source_channel, source_id, source_metadata, summary, status, linked_task_id }) => {
+  server.tool("get_last_sweep", "Get information about the last sweep run of a specific type. Useful for context about what was last reviewed.", {
+    type: exports_external.enum(["hourly", "morning_ritual", "evening_ritual"]).describe("Type of sweep")
+  }, async ({ type }) => {
     try {
-      const result = await client.createActionableEvent({
-        sourceChannel: source_channel,
-        sourceId: source_id,
-        sourceMetadata: source_metadata,
-        summary,
-        status,
-        linkedTaskId: linked_task_id
-      });
-      return formatSuccess(result);
+      const result = await client.getLastSweepRun(type);
+      return formatSuccess(result || { message: "No sweep of this type has run yet" });
     } catch (err) {
       return handleToolError(err);
     }
   });
-  server.tool("list_actionable_events", "List actionable events. Use this to review what needs attention, check for patterns, or avoid creating duplicates.", {
-    status: exports_external.optional(ActionableEventStatusSchema).describe("Filter by status"),
-    source_channel: exports_external.optional(exports_external.string()).describe("Filter by source channel"),
-    limit: exports_external.optional(exports_external.number()).describe("Maximum events to return (default: 50)")
-  }, async ({ status, source_channel, limit }) => {
+};
+var init_assistant = __esm(() => {
+  init_zod2();
+  init_utils();
+  ChannelSchema = exports_external.enum(["email", "whatsapp", "discord", "telegram", "slack", "all"]);
+});
+
+// cli/src/mcp/tools/caldav.ts
+var registerCaldavTools = (server, client) => {
+  server.tool("list_caldav_accounts", "List all CalDAV accounts configured for calendar sync.", {}, async () => {
     try {
-      const result = await client.listActionableEvents({
-        status,
-        channel: source_channel,
-        limit: limit ?? 50
-      });
-      return formatSuccess(result);
+      const accounts = await client.listCaldavAccounts();
+      return formatSuccess(accounts);
     } catch (err) {
       return handleToolError(err);
     }
   });
-  server.tool("get_actionable_event", "Get details of a specific actionable event including its action log and linked task.", {
-    id: exports_external.string().describe("Event ID")
+  server.tool("create_caldav_account", "Create a new CalDAV account with basic authentication.", {
+    name: exports_external.string().describe("Display name for the account"),
+    serverUrl: exports_external.string().describe("CalDAV server URL"),
+    username: exports_external.string().describe("Username for authentication"),
+    password: exports_external.string().describe("Password for authentication"),
+    syncIntervalMinutes: exports_external.optional(exports_external.number()).describe("Sync interval in minutes (default: 15)")
+  }, async (input) => {
+    try {
+      const account = await client.createCaldavAccount(input);
+      return formatSuccess(account);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+  server.tool("delete_caldav_account", "Delete a CalDAV account and all its calendars and events.", {
+    id: exports_external.string().describe("Account ID to delete")
   }, async ({ id }) => {
     try {
-      const result = await client.getActionableEvent(id);
+      const result = await client.deleteCaldavAccount(id);
       return formatSuccess(result);
     } catch (err) {
       return handleToolError(err);
     }
   });
-  server.tool("update_actionable_event", "Update an actionable event status, link it to a task, or add to its action log. Use action_log_entry to record decisions/actions taken.", {
-    id: exports_external.string().describe("Event ID"),
-    status: exports_external.optional(ActionableEventStatusSchema).describe("New status"),
-    linked_task_id: exports_external.optional(exports_external.string()).describe("Link to a Fulcrum task (use empty string to unlink)"),
-    action_log_entry: exports_external.optional(exports_external.string()).describe('Action to log (e.g., "Replied with project update")')
-  }, async ({ id, status, linked_task_id, action_log_entry }) => {
+  server.tool("sync_caldav_account", "Trigger a manual sync for a specific CalDAV account.", {
+    id: exports_external.string().describe("Account ID to sync")
+  }, async ({ id }) => {
     try {
-      const result = await client.updateActionableEvent(id, {
-        status,
-        linkedTaskId: linked_task_id === "" ? null : linked_task_id,
-        actionLogEntry: action_log_entry
-      });
+      const result = await client.syncCaldavAccount(id);
       return formatSuccess(result);
     } catch (err) {
       return handleToolError(err);
     }
   });
-  server.tool("get_assistant_stats", "Get assistant statistics: event counts by status and last sweep times. Useful for understanding workload and activity.", {}, async () => {
+  server.tool("list_caldav_copy_rules", "List all CalDAV copy rules for one-way event replication between calendars.", {}, async () => {
+    try {
+      const rules = await client.listCaldavCopyRules();
+      return formatSuccess(rules);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+  server.tool("create_caldav_copy_rule", "Create a copy rule to replicate events from one calendar to another.", {
+    sourceCalendarId: exports_external.string().describe("Source calendar ID"),
+    destCalendarId: exports_external.string().describe("Destination calendar ID"),
+    name: exports_external.optional(exports_external.string()).describe("Optional label for the rule")
+  }, async (input) => {
+    try {
+      const rule = await client.createCaldavCopyRule(input);
+      return formatSuccess(rule);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+  server.tool("delete_caldav_copy_rule", "Delete a CalDAV copy rule.", {
+    id: exports_external.string().describe("Copy rule ID to delete")
+  }, async ({ id }) => {
     try {
-      const result = await client.getAssistantStats();
+      const result = await client.deleteCaldavCopyRule(id);
       return formatSuccess(result);
     } catch (err) {
       return handleToolError(err);
     }
   });
-  server.tool("get_last_sweep", "Get information about the last sweep run of a specific type. Useful for context about what was last reviewed.", {
-    type: exports_external.enum(["hourly", "morning_ritual", "evening_ritual"]).describe("Type of sweep")
-  }, async ({ type }) => {
+  server.tool("execute_caldav_copy_rule", "Manually execute a copy rule to replicate events now.", {
+    id: exports_external.string().describe("Copy rule ID to execute")
+  }, async ({ id }) => {
     try {
-      const result = await client.getLastSweepRun(type);
-      return formatSuccess(result || { message: "No sweep of this type has run yet" });
+      const result = await client.executeCaldavCopyRule(id);
+      return formatSuccess(result);
     } catch (err) {
       return handleToolError(err);
     }
   });
-};
-var init_assistant_events = __esm(() => {
-  init_zod2();
-  init_utils();
-  ActionableEventStatusSchema = exports_external.enum(["pending", "acted_upon", "dismissed", "monitoring"]);
-  ChannelSchema = exports_external.enum(["email", "whatsapp", "discord", "telegram", "slack", "all"]);
-});
-
-// cli/src/mcp/tools/caldav.ts
-var registerCaldavTools = (server, client) => {
-  server.tool("list_calendars", "List all CalDAV calendars synced from the configured server.", {}, async () => {
+  server.tool("list_calendars", "List all CalDAV calendars synced from the configured server.", {
+    accountId: exports_external.optional(exports_external.string()).describe("Filter by account ID")
+  }, async ({ accountId }) => {
     try {
-      const calendars = await client.listCalendars();
+      const calendars = await client.listCalendars(accountId);
       return formatSuccess(calendars);
     } catch (err) {
       return handleToolError(err);
@@ -45884,7 +45934,7 @@ function registerTools(server, client) {
   registerSettingsTools(server, client);
   registerBackupTools(server, client);
   registerEmailTools(server, client);
-  registerAssistantEventTools(server, client);
+  registerAssistantTools(server, client);
   registerCaldavTools(server, client);
   registerMemoryTools(server, client);
 }
@@ -45900,7 +45950,7 @@ var init_tools = __esm(() => {
   init_settings();
   init_backup();
   init_email();
-  init_assistant_events();
+  init_assistant();
   init_caldav();
   init_memory();
   init_types4();
@@ -45921,7 +45971,7 @@ async function runMcpServer(urlOverride, portOverride) {
   const client = new FulcrumClient(urlOverride, portOverride);
   const server = new McpServer({
     name: "fulcrum",
-    version: "2.8.2"
+    version: "2.10.0"
   });
   registerTools(server, client);
   const transport = new StdioServerTransport;
@@ -48270,7 +48320,7 @@ var marketplace_default = `{
       "name": "fulcrum",
       "source": "./",
       "description": "Task orchestration for Claude Code",
-      "version": "2.8.2",
+      "version": "2.10.0",
       "skills": [
         "./skills/fulcrum"
       ],
@@ -49458,7 +49508,7 @@ function compareVersions(v1, v2) {
 var package_default = {
   name: "@knowsuchagency/fulcrum",
   private: true,
-  version: "2.8.2",
+  version: "2.10.0",
   description: "Harness Attention. Orchestrate Agents. Ship.",
   license: "PolyForm-Perimeter-1.0.0",
   type: "module",