@kanvas/openclaw-plugin 0.1.16 → 0.1.18

package/dist/index.js

@@ -5,11 +5,17 @@ import { InventoryService } from "./domains/inventory/index.js";
 import { OrdersService } from "./domains/orders/index.js";
 import { SocialService } from "./domains/social/index.js";
 import { EcosystemService } from "./domains/ecosystem/index.js";
+import { DealsService } from "./domains/deals/index.js";
+import { EventsService } from "./domains/events/index.js";
+import { NervousSystemService } from "./domains/nervousSystem/index.js";
 import { registerCrmTools } from "./tools/crm.js";
 import { registerInventoryTools } from "./tools/inventory.js";
 import { registerOrdersTools } from "./tools/orders.js";
 import { registerSocialTools } from "./tools/social.js";
 import { registerEcosystemTools } from "./tools/ecosystem.js";
+import { registerDealsTools } from "./tools/deals.js";
+import { registerEventsTools } from "./tools/events.js";
+import { registerNervousSystemTools } from "./tools/nervousSystem.js";
 import { toolResult } from "./tools/helpers.js";
 const DEFAULT_API_URL = "https://graphapi.kanvas.dev/graphql";
 // OpenClaw v2026.4.5+ calls register() per-agent-context (main, subagents,
@@ -23,6 +29,9 @@ let sharedInventory = null;
 let sharedOrders = null;
 let sharedSocial = null;
 let sharedEcosystem = null;
+let sharedDeals = null;
+let sharedEvents = null;
+let sharedNervousSystem = null;
 let startupBannerShown = false;
 let skipBannerShown = false;
 function resolveConfig(pluginConfig) {
@@ -115,6 +124,9 @@ export default {
             sharedOrders = new OrdersService(sharedClient);
             sharedSocial = new SocialService(sharedClient);
             sharedEcosystem = new EcosystemService(sharedClient);
+            sharedDeals = new DealsService(sharedClient);
+            sharedEvents = new EventsService(sharedClient);
+            sharedNervousSystem = new NervousSystemService(sharedClient);
         }
         // Tools and hooks must be registered on every api object — each one is
         // a separate agent context (main, subagents, cron lanes).
@@ -124,6 +136,9 @@ export default {
         registerOrdersTools(api, sharedOrders, ensureAuth);
         registerSocialTools(api, sharedSocial, ensureAuth);
         registerEcosystemTools(api, sharedEcosystem, ensureAuth);
+        registerDealsTools(api, sharedDeals, ensureAuth);
+        registerEventsTools(api, sharedEvents, ensureAuth);
+        registerNervousSystemTools(api, sharedNervousSystem, ensureAuth);
         api.registerTool({
             name: "kanvas_test_connection",
             label: "Test Connection",
@@ -148,7 +163,7 @@ export default {
         }, { commands: ["setup"] });
         if (!startupBannerShown) {
             startupBannerShown = true;
-            api.logger.info("Kanvas plugin registered — 53 tools loaded");
+            api.logger.info("Kanvas plugin registered — 84 tools loaded");
         }
     },
 };
@@ -222,6 +237,16 @@ Use when the user asks about products, stock, warehouses, or catalog.
 Use when the user asks about orders, purchases, or sales.
 - \`kanvas_search_orders\` → find orders by number or keyword
 - \`kanvas_get_order\` → full order detail with items, customer, status
+- \`kanvas_list_order_statuses\` → get status slugs for transitions
+- \`kanvas_list_order_types\` → order type pipelines (standard, subscription, etc.)
+- \`kanvas_list_regions\` → regions for order creation (get region_id)
+- \`kanvas_create_draft_order\` → create a draft order. Requires email, customer, region_id (from kanvas_list_regions), and items with variant_id+quantity (from kanvas_list_variants)
+- \`kanvas_update_order\` → update items, status, metadata
+- \`kanvas_update_draft_order_status\` → change draft order status (PENDING, COMPLETED, DRAFT, CANCELED, FAILED)
+- \`kanvas_transition_order_status\` → move through the order status pipeline (use status_slug from kanvas_list_order_statuses)
+- \`kanvas_order_change_customer\` → change the customer on an order (requires xKanvasKey)
+- \`kanvas_delete_order\` → delete an order
+- \`kanvas_send_order_email\` → send a confirmation/receipt email (requires xKanvasKey)
 
 **Follow-ups & Reminders**
 ALWAYS schedule follow-ups in Kanvas so the human team can see them — NEVER store them only in local memory.
@@ -229,6 +254,23 @@ ALWAYS schedule follow-ups in Kanvas so the human team can see them — NEVER st
 - \`kanvas_list_events\` → list scheduled events/follow-ups
 - For structured follow-up data (tracking status, priority, custom fields), use \`kanvas_create_message\` with verb "follow_up" and a JSON payload containing { due_date, lead_id, action, status, priority }.
 
+**Deals (Sales Opportunities)**
+Use when the user asks about deals, opportunities, sales tracking. A deal is a potential sale, often tied to a lead/person/organization and moved through a pipeline.
+- \`kanvas_list_deals\` → list/search deals with owner, pipeline, stage, status
+- \`kanvas_get_deal\` → full deal detail including tags and custom fields
+- \`kanvas_create_deal\` → create a deal (only title required; optionally link to lead, person, org, pipeline, owner)
+- \`kanvas_update_deal\` → update title, description, pipeline stage, owner, linked entities
+- \`kanvas_delete_deal\` → delete a deal
+
+**Events (Full event management)**
+For simple follow-ups linked to a lead, prefer \`kanvas_create_follow_up\`. Use these when the user wants richer event management (categories, types, resources, tags).
+- \`kanvas_list_events_full\` → list events with versions and dates
+- \`kanvas_get_event\` → event detail including versions, tags, custom fields
+- \`kanvas_create_event\` → create an event with one or more dates. Supports linking to resources (leads, deals), categories, types, tags.
+- \`kanvas_update_event\` → update name, description, dates, status
+- \`kanvas_delete_event\` → delete an event
+- \`kanvas_follow_event\` / \`kanvas_unfollow_event\` → subscribe/unsubscribe user to event updates
+
 **Ecosystem (Companies, Branches, Roles, Users)**
 Use when the user asks about companies, branches/locations, user management, roles, or permissions.
 - \`kanvas_list_companies\` → list/search companies
@@ -242,6 +284,21 @@ Use when the user asks about companies, branches/locations, user management, rol
 - \`kanvas_assign_role_to_user\` → assign roles (e.g. super admin). Call \`kanvas_list_roles\` first to get role IDs.
 - \`kanvas_remove_role_from_user\` → remove a role from a user
 
+**Nervous System (Plans, Tasks, Activities)**
+This is how humans assign work to you. Read the \`nervous-system-working\` skill for the full protocol. Treat every non-trivial request as a Plan; plan first, execute second. Move statuses deliberately — humans watch the kanban.
+- \`kanvas_list_my_plans\` → find work assigned to you (filter by statuses: draft/awaiting_approval/active/blocked)
+- \`kanvas_get_plan\` → full plan detail (description, input, tasks, files, parent)
+- \`kanvas_create_plan\` → create plan or sub-plan, optionally with seeded tasks
+- \`kanvas_update_plan\` → transition status (draft→active→done/blocked/failed), set output JSON, attach files
+- \`kanvas_approve_plan\` → approve/reject a plan in awaiting_approval
+- \`kanvas_add_task\` → append a task to the checklist (sequence determines order)
+- \`kanvas_update_task_status\` → pending → in_progress → done (or blocked/failed)
+- \`kanvas_list_agent_capabilities\` → list skills/tools granted to an agent
+- \`kanvas_delete_plan\` / \`kanvas_delete_task\` → delete
+- For Activities (the conversation channel), use \`kanvas_create_message\` with \`channel_slug = plan.uuid\` and \`message_verb: "comment"\`. Read with \`kanvas_list_channel_messages\` using the same slug.
+- **Always re-read the channel** before acting on a plan you've worked on before.
+- **Never act** on a plan with \`requires_human_approval=true\` until it's flipped to active.
+
 **Diagnostics**
 - \`kanvas_test_connection\` → verify the API is reachable
 

package/dist/tools/deals.js

@@ -0,0 +1,91 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+const WhereClause = Type.Optional(Type.Array(Type.Object({
+    column: Type.String(),
+    operator: Type.String({ description: 'e.g. "EQ", "LIKE"' }),
+    value: Type.Unknown(),
+}), { description: "Filter conditions" }));
+export function registerDealsTools(api, service, ensureAuth) {
+    api.registerTool({
+        name: "kanvas_list_deals",
+        label: "List Deals",
+        description: "List or search deals. A deal represents a potential sale/opportunity linked to a lead, person, or organization.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 25)" })),
+            search: Type.Optional(Type.String({ description: "Search keyword" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listDeals(params.first, params.search, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_deal",
+        label: "Get Deal",
+        description: "Get full details for a deal by ID, including pipeline stage, owner, linked lead/person/org, tags, and custom fields.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Deal ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getDeal(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_create_deal",
+        label: "Create Deal",
+        description: "Create a deal. Only title is required. Optionally link to a lead, person, organization, or pipeline stage.",
+        parameters: Type.Object({
+            title: Type.String({ description: "Deal title" }),
+            description: Type.Optional(Type.String()),
+            leads_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Linked lead ID" })),
+            people_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Linked person ID" })),
+            organization_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            owner_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Deal owner user ID" })),
+            pipeline_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            pipeline_stage_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Number()),
+            companies_branches_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createDeal(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_deal",
+        label: "Update Deal",
+        description: "Update a deal's title, description, pipeline stage, owner, or linked entities.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Deal ID" }),
+            title: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            leads_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            people_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            organization_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            owner_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            pipeline_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            pipeline_stage_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Number()),
+            companies_branches_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { id, ...input } = params;
+            return toolResult(await service.updateDeal(id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_deal",
+        label: "Delete Deal",
+        description: "Delete a deal by ID.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Deal ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deleteDeal(params.id));
+        },
+    });
+}

package/dist/tools/events.js

@@ -0,0 +1,134 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+const WhereClause = Type.Optional(Type.Array(Type.Object({
+    column: Type.String(),
+    operator: Type.String({ description: 'e.g. "EQ", "LIKE"' }),
+    value: Type.Unknown(),
+}), { description: "Filter conditions" }));
+const EventDateInput = Type.Object({
+    date: Type.String({ description: "YYYY-MM-DD" }),
+    start_time: Type.String({ description: "HH:MM (24h)" }),
+    end_time: Type.String({ description: "HH:MM (24h)" }),
+});
+const EventResourceInput = Type.Object({
+    resources_id: Type.String({ description: "Entity ID this event is attached to" }),
+    resources_type: Type.String({ description: 'e.g. "lead", "deal"' }),
+});
+const TagInput = Type.Object({
+    name: Type.String(),
+    slug: Type.Optional(Type.String()),
+});
+export function registerEventsTools(api, service, ensureAuth) {
+    api.registerTool({
+        name: "kanvas_list_events_full",
+        label: "List Events (full)",
+        description: "List or search events with full details. For follow-ups only, see kanvas_list_events.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 25)" })),
+            search: Type.Optional(Type.String({ description: "Search keyword" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listEvents(params.first, params.search, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_event",
+        label: "Get Event",
+        description: "Get full details for an event by ID, including versions, dates, tags, and custom fields.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Event ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getEvent(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_create_event",
+        label: "Create Event",
+        description: "Create an event with dates. Supports linking to resources (leads, deals) and categorization. For a simple lead follow-up, use kanvas_create_follow_up.",
+        parameters: Type.Object({
+            name: Type.String({ description: "Event name" }),
+            slug: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            dates: Type.Array(EventDateInput, { description: "At least one date (YYYY-MM-DD + HH:MM times)" }),
+            type_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            class_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            category_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            theme_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            theme_area_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            resources: Type.Optional(Type.Array(EventResourceInput)),
+            participants: Type.Optional(Type.Array(Type.String())),
+            tags: Type.Optional(Type.Array(TagInput)),
+            custom_fields: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createEvent(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_event",
+        label: "Update Event",
+        description: "Update an event's name, description, dates, status, or linked resources.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Event ID" }),
+            name: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            dates: Type.Optional(Type.Array(EventDateInput)),
+            type_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            class_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            category_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            resources_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            resources_type: Type.Optional(Type.String()),
+            tags: Type.Optional(Type.Array(TagInput)),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { id, ...input } = params;
+            return toolResult(await service.updateEvent(id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_event",
+        label: "Delete Event",
+        description: "Delete an event by ID.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Event ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deleteEvent(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_follow_event",
+        label: "Follow Event",
+        description: "Subscribe a user to event updates.",
+        parameters: Type.Object({
+            entity_id: Type.String({ description: "Event UUID" }),
+            user_id: Type.Union([Type.String(), Type.Number()], { description: "User ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.followEvent(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_unfollow_event",
+        label: "Unfollow Event",
+        description: "Unsubscribe a user from event updates.",
+        parameters: Type.Object({
+            entity_id: Type.String({ description: "Event UUID" }),
+            user_id: Type.Union([Type.String(), Type.Number()], { description: "User ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.unFollowEvent(params));
+        },
+    });
+}

package/dist/tools/nervousSystem.js

@@ -0,0 +1,217 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+const TaskInputSchema = Type.Object({
+    title: Type.String({ description: "Task title (verb phrase, e.g. 'Crawl /features')" }),
+    sequence: Type.Optional(Type.Number({ description: "Execution order (0, 1, 2...)" })),
+    description: Type.Optional(Type.String()),
+    status: Type.Optional(Type.String({ description: "pending | in_progress | blocked | done | failed | cancelled" })),
+    result: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    blocked_reason: Type.Optional(Type.String()),
+});
+const FilesInputSchema = Type.Array(Type.Object({
+    url: Type.String({ description: "Public URL of the file" }),
+    name: Type.String({ description: "Display name" }),
+    field_name: Type.Optional(Type.String()),
+}), { description: "Files to attach (appended, not replaced)" });
+const PlanStatusSchema = Type.String({
+    description: "Plan status: draft | awaiting_approval | active | blocked | done | failed | cancelled",
+});
+const TaskStatusSchema = Type.String({
+    description: "Task status: pending | in_progress | blocked | done | failed | cancelled",
+});
+export function registerNervousSystemTools(api, service, ensureAuth) {
+    // ── Read ───────────────────────────────────────────────────
+    api.registerTool({
+        name: "kanvas_list_my_plans",
+        label: "List My Plans",
+        description: "List nervous-system plans assigned to an agent. Filter by statuses to see open work " +
+            "(e.g. ['draft','awaiting_approval','active','blocked']). Returns plans ordered by priority desc, deadline asc.",
+        parameters: Type.Object({
+            agent_id: Type.Union([Type.String(), Type.Number()], { description: "The agent's ID" }),
+            statuses: Type.Optional(Type.Array(Type.String(), {
+                description: "Statuses to include. Default: all.",
+            })),
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listMyPlans(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_plans",
+        label: "List Plans (admin)",
+        description: "List nervous-system plans with arbitrary where filters. Allowed where columns: " +
+            "ID, UUID, AGENT_ID, USERS_ID, ENTITY_NAMESPACE, ENTITY_ID, PLAN_TYPE, STATUS, PRIORITY, PARENT_PLAN_ID.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 25)" })),
+            where: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            orderBy: Type.Optional(Type.Array(Type.Object({
+                column: Type.String(),
+                order: Type.String({ description: "ASC or DESC" }),
+            }))),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listPlans(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_plan",
+        label: "Get Plan",
+        description: "Get full plan detail: description, input/output, tasks, files, tags, agent, user, parent, completion %.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Plan ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getPlan(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_agent_capabilities",
+        label: "List Agent Capabilities",
+        description: "List the skills and tools an agent has been granted. Use this to verify you can do something before agreeing to a plan.",
+        parameters: Type.Object({
+            agent_id: Type.String({ description: "Agent ID" }),
+            framework: Type.Optional(Type.String({ description: "Framework filter (optional)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getAgentCapabilities(params.agent_id, params.framework));
+        },
+    });
+    // ── Plan write ─────────────────────────────────────────────
+    api.registerTool({
+        name: "kanvas_create_plan",
+        label: "Create Plan",
+        description: "Create a nervous-system plan (or sub-plan when parent_plan_id is provided). " +
+            "Include a tasks array to seed the checklist on creation. For sensitive work, set requires_human_approval=true " +
+            "to gate the plan in awaiting_approval status until a human approves.",
+        parameters: Type.Object({
+            title: Type.String(),
+            plan_type: Type.String({ description: 'e.g. "data_migration", "outreach", "report_generation"' }),
+            description: Type.Optional(Type.String()),
+            agent_id: Type.Optional(Type.Number()),
+            users_id: Type.Optional(Type.Number()),
+            parent_plan_id: Type.Optional(Type.Number()),
+            entity_namespace: Type.Optional(Type.String({ description: "FQCN of the related entity (e.g. App\\\\Models\\\\Lead)" })),
+            entity_id: Type.Optional(Type.Number()),
+            status: Type.Optional(PlanStatusSchema),
+            priority: Type.Optional(Type.Number({ description: "Higher = more important" })),
+            deadline_at: Type.Optional(Type.String({ description: "ISO datetime" })),
+            input: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            output: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            confidence_score: Type.Optional(Type.Number()),
+            requires_human_approval: Type.Optional(Type.Boolean()),
+            tasks: Type.Optional(Type.Array(TaskInputSchema)),
+            files: Type.Optional(FilesInputSchema),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createPlan(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_plan",
+        label: "Update Plan",
+        description: "Update a plan's status, title, description, output, or attach files. " +
+            "Use status transitions to signal progress: draft→active to start, active→blocked when stuck, active→done/failed when finished.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Plan ID" }),
+            title: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            status: Type.Optional(PlanStatusSchema),
+            priority: Type.Optional(Type.Number()),
+            deadline_at: Type.Optional(Type.String()),
+            input: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            output: Type.Optional(Type.Record(Type.String(), Type.Unknown()), {
+                description: "Final output JSON (set this before flipping to done)",
+            }),
+            confidence_score: Type.Optional(Type.Number()),
+            requires_human_approval: Type.Optional(Type.Boolean()),
+            files: Type.Optional(FilesInputSchema),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { id, ...input } = params;
+            return toolResult(await service.updatePlan(id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_approve_plan",
+        label: "Approve Plan",
+        description: "Approve or reject a plan that is in awaiting_approval status. Approving flips it to active; rejecting flips it to cancelled.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Plan ID" }),
+            approved: Type.Boolean({ description: "true to approve, false to reject" }),
+            review_outcome: Type.Optional(Type.String({ description: "Optional reviewer note" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.approvePlan(params.id, {
+                approved: params.approved,
+                review_outcome: params.review_outcome,
+            }));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_plan",
+        label: "Delete Plan",
+        description: "Delete a plan by ID.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Plan ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deletePlan(params.id));
+        },
+    });
+    // ── Task write ─────────────────────────────────────────────
+    api.registerTool({
+        name: "kanvas_add_task",
+        label: "Add Task to Plan",
+        description: "Append a task to a plan's checklist. Sequence determines execution order (0, 1, 2...).",
+        parameters: Type.Object({
+            plan_id: Type.String({ description: "Plan ID" }),
+            title: Type.String({ description: "Task title (verb phrase)" }),
+            sequence: Type.Optional(Type.Number()),
+            description: Type.Optional(Type.String()),
+            status: Type.Optional(TaskStatusSchema),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { plan_id, ...input } = params;
+            return toolResult(await service.addTask(plan_id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_task_status",
+        label: "Update Task Status",
+        description: "Move a task through its lifecycle: pending → in_progress → done (or blocked/failed/cancelled). " +
+            "Set 'result' as JSON when done; set 'blocked_reason' when blocked.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Task ID" }),
+            status: TaskStatusSchema,
+            result: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            blocked_reason: Type.Optional(Type.String()),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            const { id, ...input } = params;
+            return toolResult(await service.updateTaskStatus(id, input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_task",
+        label: "Delete Task",
+        description: "Delete a task by ID.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Task ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deleteTask(params.id));
+        },
+    });
+}