@opsee/mcp-server 0.6.1 → 0.6.4

package/src/__tests__/tools.test.ts

@@ -102,6 +102,73 @@ function createMockClients(): ApiClients {
       getTask: async () => ({ task: mockTask }),
       addTask: async () => ({ task: mockTask }),
       editTask: async () => ({ task: { ...mockTask, title: "Updated bug" } }),
+      bulkEditTasks: async (req: { taskIds: number[] }) => ({
+        updatedCount: req.taskIds.length,
+      }),
+      deleteTask: async () => ({}),
+      bulkDeleteTasks: async () => ({ deletedCount: 2 }),
+      addWorkLog: async (req: { taskId: number; hours: number }) => ({
+        workLog: { id: 42, taskId: req.taskId, userId: 5, hours: req.hours },
+      }),
+      deleteWorkLog: async () => ({}),
+    },
+    comments: {
+      getComment: async () => ({ comment: { id: 11, content: "old text", isInternal: false, taskId: 10, userId: 5 } }),
+      getComments: async () => ({ comments: [] }),
+      editComment: async () => ({ comment: { id: 11, content: "edited text", isInternal: true, taskId: 10, userId: 5 } }),
+    },
+    taskLabels: {
+      getTaskLabels: async () => ({ taskLabels: [] }),
+    },
+    taskDependencies: {
+      getTaskDependencies: async () => ({ taskDependencies: [] }),
+      getDependencyChain: async () => ({
+        nodes: [{ id: 10, identifier: "TP-1", title: "Fix the bug" }],
+        edges: [],
+      }),
+    },
+    acceptanceCriteria: {
+      getAcceptanceCriteriaByTask: async () => ({
+        criteria: [{ id: 1, taskId: 10, text: "endpoint returns 200", done: false, displayOrder: 0 }],
+      }),
+      addAcceptanceCriterion: async (req: { taskId: number; text: string; displayOrder?: number }) => ({
+        criterion: { id: 2, taskId: req.taskId, text: req.text, done: false, displayOrder: req.displayOrder ?? 0 },
+      }),
+      editAcceptanceCriterion: async (req: { id: number; text?: string; done?: boolean }) => ({
+        criterion: { id: req.id, taskId: 10, text: req.text ?? "old", done: req.done ?? true, displayOrder: 0 },
+      }),
+      deleteAcceptanceCriterion: async () => ({}),
+    },
+    notifications: {
+      getNotifications: async () => ({
+        notifications: [
+          {
+            id: 1,
+            title: "You were assigned to TP-1",
+            message: "Alice assigned you",
+            notificationType: "task_assigned",
+            entityType: "task",
+            entityId: 10,
+            isRead: false,
+            sentViaEmail: false,
+            userId: 5,
+          },
+        ],
+      }),
+      getNotification: async () => ({
+        notification: {
+          id: 1,
+          title: "You were assigned to TP-1",
+          message: "Alice assigned you",
+          notificationType: "task_assigned",
+          isRead: false,
+          sentViaEmail: false,
+          userId: 5,
+        },
+      }),
+      editNotification: async () => ({
+        notification: { id: 1, title: "x", message: "y", notificationType: "task_assigned", isRead: true, sentViaEmail: false, userId: 5 },
+      }),
     },
     boards: {
       getBoards: async () => ({ boards: [mockBoard] }),
@@ -111,8 +178,10 @@ function createMockClients(): ApiClients {
     },
     cycles: {
       getCycles: async () => ({ cycles: [mockCycle] }),
-      getCycle: async () => ({ cycle: mockCycle }),
-      addCycle: async () => ({ cycle: mockCycle }),
+      getCycle: async () => ({ cycle: { ...mockCycle, projectId: 1 } }),
+      addCycle: async () => ({ cycle: { ...mockCycle, id: 2, name: "Sprint 2" } }),
+      editCycle: async () => ({ cycle: { ...mockCycle, name: "Sprint 1 renamed" } }),
+      deleteCycle: async () => ({}),
     },
     docSpaces: {
       getDocSpaces: async () => ({ docSpaces: [mockDocSpace] }),
@@ -338,7 +407,7 @@ describe("MCP Tools", () => {
     const text = (result.content as Array<{ type: string; text: string }>)[0]
       .text;
     expect(text).toContain("Cycle created");
-    expect(text).toContain("Sprint 1");
+    expect(text).toContain("Sprint 2");
   });
 
   // --- Doc tools ---
@@ -435,6 +504,343 @@ describe("MCP Tools", () => {
     await errorServer.close();
   });
 
+  // --- Track 3 bulk + cycle + label additions ---
+
+  test("opsee_create_task accepts labelIds and returns the task", async () => {
+    const result = await client.callTool({
+      name: "opsee_create_task",
+      arguments: { projectId: 1, title: "with labels", labelIds: [1, 2] },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Task created");
+    expect(text).toContain("TP-1");
+  });
+
+  test("opsee_update_task accepts labelIds replace-set", async () => {
+    const result = await client.callTool({
+      name: "opsee_update_task",
+      arguments: { taskId: 10, labelIds: [3] },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Task updated");
+  });
+
+  test("opsee_bulk_update_tasks reports per-task count", async () => {
+    const result = await client.callTool({
+      name: "opsee_bulk_update_tasks",
+      arguments: { projectId: 1, taskIds: [10, 11, 12], boardColumnId: 5 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Updated 3 of 3");
+  });
+
+  test("opsee_bulk_update_tasks accepts storyPoints/estimatedHours/parentTaskId/labelIds", async () => {
+    const result = await client.callTool({
+      name: "opsee_bulk_update_tasks",
+      arguments: {
+        projectId: 1,
+        taskIds: [10, 11],
+        storyPoints: 5,
+        estimatedHours: 8,
+        parentTaskId: 3,
+        labelIds: [1, 2],
+      },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Updated 2 of 2");
+  });
+
+  test("opsee_bulk_move_to_cycle delegates to bulk edit", async () => {
+    const result = await client.callTool({
+      name: "opsee_bulk_move_to_cycle",
+      arguments: { projectId: 1, taskIds: [10, 11], cycleId: 7 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Moved 2 of 2");
+    expect(text).toContain("cycle 7");
+  });
+
+  test("opsee_bulk_move_to_column delegates to bulk edit", async () => {
+    const result = await client.callTool({
+      name: "opsee_bulk_move_to_column",
+      arguments: { projectId: 1, taskIds: [10], boardColumnId: 5 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Moved 1 of 1");
+    expect(text).toContain("column 5");
+  });
+
+  test("opsee_bulk_assign delegates to bulk edit", async () => {
+    const result = await client.callTool({
+      name: "opsee_bulk_assign",
+      arguments: { projectId: 1, taskIds: [10, 11, 12], assigneeId: 5 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Assigned 3 of 3");
+    expect(text).toContain("user 5");
+  });
+
+  test("opsee_bulk_set_priority delegates to bulk edit", async () => {
+    const result = await client.callTool({
+      name: "opsee_bulk_set_priority",
+      arguments: { projectId: 1, taskIds: [10], priorityId: 2 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Set priority 2");
+    expect(text).toContain("1 of 1");
+  });
+
+  test("opsee_replace_task_labels with a set returns count", async () => {
+    const result = await client.callTool({
+      name: "opsee_replace_task_labels",
+      arguments: { taskId: 10, labelIds: [1, 2, 3] },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Set 3 label(s)");
+  });
+
+  test("opsee_replace_task_labels with empty clears", async () => {
+    const result = await client.callTool({
+      name: "opsee_replace_task_labels",
+      arguments: { taskId: 10, labelIds: [] },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Cleared all labels");
+  });
+
+  test("opsee_update_cycle returns the renamed cycle", async () => {
+    const result = await client.callTool({
+      name: "opsee_update_cycle",
+      arguments: { cycleId: 1, name: "Sprint 1 renamed" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Cycle updated");
+    expect(text).toContain("Sprint 1 renamed");
+  });
+
+  test("opsee_close_cycle closes and carries forward", async () => {
+    const result = await client.callTool({
+      name: "opsee_close_cycle",
+      arguments: { cycleId: 1, nextCycleId: 2 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("closed");
+    // mockTask is returned by getTasks, so we should see a carry-forward count.
+    expect(text).toContain("Carried 1 task(s) forward to cycle 2");
+  });
+
+  test("opsee_close_cycle rejects mutually exclusive args", async () => {
+    const result = await client.callTool({
+      name: "opsee_close_cycle",
+      arguments: { cycleId: 1, nextCycleId: 2, createNextCycle: true },
+    });
+    expect(result.isError).toBe(true);
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("mutually exclusive");
+  });
+
+  test("opsee_get_active_cycle returns the active one", async () => {
+    const result = await client.callTool({
+      name: "opsee_get_active_cycle",
+      arguments: { projectId: 1 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Sprint 1");
+  });
+
+  test("opsee_delete_cycle succeeds", async () => {
+    const result = await client.callTool({
+      name: "opsee_delete_cycle",
+      arguments: { cycleId: 1 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Cycle deleted");
+  });
+
+  // --- Track 1 defect fixes ---
+
+  test("opsee_delete_task succeeds", async () => {
+    const result = await client.callTool({
+      name: "opsee_delete_task",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Task deleted");
+  });
+
+  test("opsee_bulk_delete_tasks reports counts", async () => {
+    const result = await client.callTool({
+      name: "opsee_bulk_delete_tasks",
+      arguments: { projectId: 1, taskIds: [10, 11] },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Deleted 2 of 2");
+  });
+
+  test("opsee_edit_comment updates content", async () => {
+    const result = await client.callTool({
+      name: "opsee_edit_comment",
+      arguments: { commentId: 11, content: "edited text", isInternal: true },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Comment updated");
+    expect(text).toContain("edited text");
+  });
+
+  test("opsee_get_task_with_context composes related data", async () => {
+    const result = await client.callTool({
+      name: "opsee_get_task_with_context",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("TP-1");
+    expect(text).toContain("--- Labels ---");
+    expect(text).toContain("--- Dependencies ---");
+    expect(text).toContain("--- Subtasks ---");
+    expect(text).toContain("--- Comments ---");
+  });
+
+  // --- Acceptance Criteria (§3.7) ---
+
+  test("opsee_list_task_acceptance_criteria lists items", async () => {
+    const result = await client.callTool({
+      name: "opsee_list_task_acceptance_criteria",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("endpoint returns 200");
+    expect(text).toContain("[ ]");
+  });
+
+  test("opsee_add_acceptance_criterion returns the new criterion", async () => {
+    const result = await client.callTool({
+      name: "opsee_add_acceptance_criterion",
+      arguments: { taskId: 10, text: "deploy to staging" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Criterion added");
+    expect(text).toContain("deploy to staging");
+  });
+
+  test("opsee_update_acceptance_criterion toggles done", async () => {
+    const result = await client.callTool({
+      name: "opsee_update_acceptance_criterion",
+      arguments: { criterionId: 1, done: true },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Criterion updated");
+    expect(text).toContain("[x]");
+  });
+
+  test("opsee_delete_acceptance_criterion succeeds", async () => {
+    const result = await client.callTool({
+      name: "opsee_delete_acceptance_criterion",
+      arguments: { criterionId: 1 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Acceptance criterion deleted");
+  });
+
+  // --- Notifications (§15) ---
+
+  test("opsee_list_my_notifications returns notifications", async () => {
+    const result = await client.callTool({
+      name: "opsee_list_my_notifications",
+      arguments: {},
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("notification(s)");
+    expect(text).toContain("task_assigned");
+    expect(text).toContain("unread");
+  });
+
+  test("opsee_list_my_notifications unreadOnly returns unread header", async () => {
+    const result = await client.callTool({
+      name: "opsee_list_my_notifications",
+      arguments: { unreadOnly: true },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("unread notification");
+  });
+
+  test("opsee_mark_notification_read flips is_read", async () => {
+    const result = await client.callTool({
+      name: "opsee_mark_notification_read",
+      arguments: { notificationId: 1 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("marked read");
+  });
+
+  test("opsee_mark_all_notifications_read summarizes", async () => {
+    const result = await client.callTool({
+      name: "opsee_mark_all_notifications_read",
+      arguments: {},
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Marked 1 of 1");
+  });
+
+  test("opsee_get_dependency_chain returns nodes and edges summary", async () => {
+    const result = await client.callTool({
+      name: "opsee_get_dependency_chain",
+      arguments: { taskId: 10, direction: "both", depth: 3 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Dependency chain from task 10");
+    expect(text).toContain("1 task(s), 0 edge(s)");
+    expect(text).toContain("[TP-1]");
+  });
+
+  // --- WorkLog tools (§12) ---
+
+  test("opsee_log_work logs hours", async () => {
+    const result = await client.callTool({
+      name: "opsee_log_work",
+      arguments: { taskId: 10, hours: 2.5, description: "implemented foo" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Logged 2.5h on task 10");
+  });
+
+  test("opsee_delete_work_log succeeds", async () => {
+    const result = await client.callTool({
+      name: "opsee_delete_work_log",
+      arguments: { taskId: 10, workLogId: 42 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Work log deleted");
+  });
+
+  test("opsee_list_work_logs reports empty for tasks without logs", async () => {
+    const result = await client.callTool({
+      name: "opsee_list_work_logs",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("No work logs");
+  });
+
+  test("opsee_get_task_actual_hours sums to 0 with no logs", async () => {
+    const result = await client.callTool({
+      name: "opsee_get_task_actual_hours",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("TP-1");
+    expect(text).toContain("0h logged");
+  });
+
+  test("formatTask surfaces storyPoints and estimatedHours", async () => {
+    // mockTask has storyPoints: 3 — confirms D4 fix.
+    const result = await client.callTool({
+      name: "opsee_get_task",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Story Points: 3");
+  });
+
   test("auth error returns login instruction", async () => {
     const authClients = createMockClients();
     (authClients.users as any).getMe = async () => {

package/src/client/api.ts

@@ -26,6 +26,8 @@ import { LabelService } from "../../gen/api/v1/label_pb.js";
 import { TaskLabelService } from "../../gen/api/v1/task_label_pb.js";
 import { CommentService } from "../../gen/api/v1/comment_pb.js";
 import { TaskDependencyService } from "../../gen/api/v1/task_dependency_pb.js";
+import { NotificationService } from "../../gen/api/v1/notification_pb.js";
+import { AcceptanceCriterionService } from "../../gen/api/v1/acceptance_criterion_pb.js";
 
 const authInterceptor: Interceptor = (next) => async (req) => {
   // Remote mode: token from AsyncLocalStorage (per-request)
@@ -105,6 +107,8 @@ export type ApiClients = {
   taskLabels: Client<typeof TaskLabelService>;
   comments: Client<typeof CommentService>;
   taskDependencies: Client<typeof TaskDependencyService>;
+  notifications: Client<typeof NotificationService>;
+  acceptanceCriteria: Client<typeof AcceptanceCriterionService>;
 };
 
 export function getClients(): ApiClients {
@@ -127,6 +131,8 @@ export function getClients(): ApiClients {
       taskLabels: makeClient(TaskLabelService),
       comments: makeClient(CommentService),
       taskDependencies: makeClient(TaskDependencyService),
+      notifications: makeClient(NotificationService),
+      acceptanceCriteria: makeClient(AcceptanceCriterionService),
     };
   }
   return cachedClients;

package/src/server.ts

@@ -11,6 +11,9 @@ import { registerMilestoneTools } from "./tools/milestones.js";
 import { registerLabelTools } from "./tools/labels.js";
 import { registerCommentTools } from "./tools/comments.js";
 import { registerTaskDependencyTools } from "./tools/task-dependencies.js";
+import { registerWorkLogTools } from "./tools/work-logs.js";
+import { registerNotificationTools } from "./tools/notifications.js";
+import { registerAcceptanceCriterionTools } from "./tools/acceptance-criteria.js";
 
 export function createServer(clientFactory?: () => ApiClients): McpServer {
   const factory = clientFactory ?? getClients;
@@ -31,6 +34,9 @@ export function createServer(clientFactory?: () => ApiClients): McpServer {
   registerLabelTools(server, factory);
   registerCommentTools(server, factory);
   registerTaskDependencyTools(server, factory);
+  registerWorkLogTools(server, factory);
+  registerNotificationTools(server, factory);
+  registerAcceptanceCriterionTools(server, factory);
 
   return server;
 }

package/src/tools/acceptance-criteria.ts

@@ -0,0 +1,127 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClients } from "../client/api.js";
+import { formatError } from "../utils/format.js";
+
+// Structured Acceptance Criterion entity — SECONDARY path.
+//
+// The PRIMARY way to record AC on an Opsee task is markdown inside the
+// task description: a `## Acceptance criteria` heading followed by
+// `- [ ]` / `- [x]` checkbox lines. BlockNote renders those as
+// clickable checkbox blocks in the task detail UI. /tpm and any other
+// AI agent should write AC via opsee_update_task's description field
+// using that convention.
+//
+// These four tools operate on a SEPARATE DB entity (acceptance_criteria
+// table) intended for automation paths that need machine-trackable AC
+// outside the description — PR-to-criterion mapping, AI workflow
+// outputs, reporting. They do NOT surface in the current task detail
+// UI; do not use them as the default AC write path.
+
+function formatCriterion(c: {
+  id: number;
+  text: string;
+  done: boolean;
+  displayOrder: number;
+}): string {
+  const box = c.done ? "[x]" : "[ ]";
+  return `${box} ${c.text} (ID: ${c.id}, order: ${c.displayOrder})`;
+}
+
+export function registerAcceptanceCriterionTools(
+  server: McpServer,
+  getClients: () => ApiClients,
+): void {
+  server.tool(
+    "opsee_list_task_acceptance_criteria",
+    "Lists STRUCTURED acceptance criteria from a separate DB entity, NOT the checklist items inside the task description. Most tasks have their AC inline in the description as `- [ ]` markdown — to read those, fetch the task description via opsee_get_task and parse the checklist lines yourself. This tool only returns rows from the `acceptance_criteria` table, which is the automation/power-user path, not the main UI. Returns items ordered by display_order then id with text + done flag + display_order.",
+    { taskId: z.number().describe("The task ID") },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ taskId }) => {
+      try {
+        const clients = getClients();
+        const res = await clients.acceptanceCriteria.getAcceptanceCriteriaByTask({ taskId });
+        const items = res.criteria ?? [];
+        if (items.length === 0) {
+          return { content: [{ type: "text", text: `No acceptance criteria on task ${taskId}.` }] };
+        }
+        const lines = items.map((c: Parameters<typeof formatCriterion>[0], i: number) => `${i + 1}. ${formatCriterion(c)}`);
+        return { content: [{ type: "text", text: `Acceptance criteria for task ${taskId}:\n` + lines.join("\n") }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: formatError(error) }], isError: true };
+      }
+    },
+  );
+
+  server.tool(
+    "opsee_add_acceptance_criterion",
+    "POWER-USER PATH — writes a STRUCTURED criterion to the `acceptance_criteria` DB table, which does NOT surface in the task detail UI. For typical AC, use opsee_update_task and write `- [ ]` checkbox lines under a `## Acceptance criteria` heading in the task description instead — those render as clickable checkboxes via BlockNote. Use this tool only when you need machine-trackable AC for automation (e.g. mapping criteria to PRs, AI workflow outputs, reporting). display_order defaults to 0; pass an explicit value to control ordering.",
+    {
+      taskId: z.number().describe("The task ID"),
+      text: z.string().min(1).max(2000).describe("Criterion text (what passing this AC looks like)"),
+      displayOrder: z.number().int().optional().describe("Display order (default: 0)"),
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ taskId, text, displayOrder }) => {
+      try {
+        const clients = getClients();
+        const res = await clients.acceptanceCriteria.addAcceptanceCriterion({
+          taskId,
+          text,
+          displayOrder: displayOrder ?? 0,
+        });
+        if (!res.criterion) {
+          return { content: [{ type: "text", text: "Failed to add acceptance criterion. The backend returned an empty response." }], isError: true };
+        }
+        return { content: [{ type: "text", text: `Criterion added:\n${formatCriterion(res.criterion)}` }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: formatError(error) }], isError: true };
+      }
+    },
+  );
+
+  server.tool(
+    "opsee_update_acceptance_criterion",
+    "POWER-USER PATH — patches a STRUCTURED criterion in the `acceptance_criteria` DB table. Does NOT touch description-embedded checkboxes; those live in the task description and are edited via opsee_update_task's description field. Use this only for the automation path that created the criterion via opsee_add_acceptance_criterion. Patch semantics: any subset of text / done / displayOrder; fields not supplied are left alone.",
+    {
+      criterionId: z.number().describe("The criterion ID"),
+      text: z.string().max(2000).optional().describe("New text"),
+      done: z.boolean().optional().describe("Mark complete or incomplete"),
+      displayOrder: z.number().int().optional().describe("New display order"),
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ criterionId, text, done, displayOrder }) => {
+      try {
+        const clients = getClients();
+        const res = await clients.acceptanceCriteria.editAcceptanceCriterion({
+          id: criterionId,
+          text,
+          done,
+          displayOrder,
+        });
+        if (!res.criterion) {
+          return { content: [{ type: "text", text: "Failed to update acceptance criterion. The backend returned an empty response." }], isError: true };
+        }
+        return { content: [{ type: "text", text: `Criterion updated:\n${formatCriterion(res.criterion)}` }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: formatError(error) }], isError: true };
+      }
+    },
+  );
+
+  server.tool(
+    "opsee_delete_acceptance_criterion",
+    "POWER-USER PATH — deletes a STRUCTURED criterion row from the `acceptance_criteria` DB table by ID. Does NOT remove `- [ ]` lines from a task description; for those, edit the description via opsee_update_task. Soft delete; this is permanent at the application layer.",
+    { criterionId: z.number().describe("The criterion ID") },
+    { readOnlyHint: false, destructiveHint: true },
+    async ({ criterionId }) => {
+      try {
+        const clients = getClients();
+        await clients.acceptanceCriteria.deleteAcceptanceCriterion({ id: criterionId });
+        return { content: [{ type: "text", text: "Acceptance criterion deleted." }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: formatError(error) }], isError: true };
+      }
+    },
+  );
+}

package/src/tools/comments.ts

@@ -68,7 +68,7 @@ export function registerCommentTools(
         });
 
         if (!res.comment) {
-          return { content: [{ type: "text", text: "Failed to add comment." }] };
+          return { content: [{ type: "text", text: "Failed to add comment. The backend returned an empty response (no error). Retry; if it persists, surface the call to the Opsee team." }], isError: true };
         }
 
         return { content: [{ type: "text", text: `Comment added:\n${formatComment(res.comment)}` }] };
@@ -78,6 +78,45 @@ export function registerCommentTools(
     },
   );
 
+  server.tool(
+    "opsee_edit_comment",
+    "Edit an existing comment's content and/or internal flag. Posts as the original author. Use opsee_list_comments first to confirm the comment ID.",
+    {
+      commentId: z.number().describe("The comment ID to edit"),
+      content: z.string().min(1).describe("New comment body"),
+      isInternal: z.boolean().optional().describe("Update the internal flag (defaults to the comment's existing value if omitted)"),
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ commentId, content, isInternal }) => {
+      try {
+        const clients = getClients();
+
+        const getRes = await clients.comments.getComment({ id: commentId });
+        const existing = getRes.comment;
+        if (!existing) {
+          return { content: [{ type: "text", text: "Comment not found. Use opsee_list_comments to see available comments." }] };
+        }
+
+        const res = await clients.comments.editComment({
+          id: existing.id,
+          content,
+          isInternal: isInternal ?? existing.isInternal,
+          taskId: existing.taskId,
+          docPageId: existing.docPageId,
+          userId: existing.userId,
+        });
+
+        if (!res.comment) {
+          return { content: [{ type: "text", text: "Failed to edit comment. The backend returned an empty response (no error). Retry; if it persists, surface the call to the Opsee team." }], isError: true };
+        }
+
+        return { content: [{ type: "text", text: `Comment updated:\n${formatComment(res.comment)}` }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: formatError(error) }], isError: true };
+      }
+    },
+  );
+
   server.tool(
     "opsee_delete_comment",
     "Delete a comment by ID. This is permanent.",