@myspec/mcp-server 1.1.1-next.165 → 1.1.1-next.166

package/README.md

@@ -363,9 +363,10 @@ Local state is stored under `~/.myspec/` (alongside the on-disk cache root), spl
 | `reply_spec_file_comment_thread` | `file_id`, `thread_id`, `body` | Replies to an existing thread. Conflicts on a trashed file |
 | `update_spec_file_comment` | `file_id`, `comment_id`, `body`, optional `expected_version` | Edits the body of one of YOUR OWN comments; the platform refuses somebody else's. `expected_version` is the **comment's** own `content_version`, not the file's — pairing it with the file would fail an edit because somebody saved the document. Works on a trashed file |
 | `delete_spec_file_comment` | `file_id`, `comment_id` | Soft-deletes one of YOUR OWN comments. Three outcomes, reported in the result: a reply disappears (`comment: null`); a first comment with live replies becomes a tombstone so the thread keeps a head (`comment` is the tombstone); a first comment with no live replies takes the whole thread (`thread_deleted: true`) |
-| `list_tasks` | `project_id`, optional `status`, `assignee_user_id`, `cycle`, `label`, `file_id`, `include_details`, `limit`, `offset` | The project's task board: every checkbox task in its tasks.md files, in file order, each with a stable `task_id`, `status` (`pending`/`in_progress`/`done`), assignee, `priority` (0 none … 4 low, plus `priority_name`), `story_points`, `cycle`, `start_date`/`end_date` (calendar days, `YYYY-MM-DD`), `labels`, and with `include_details` a 500-character preview of its details. Also the files and the labels and cycles in use. Paged: 100 tasks by default (`limit` up to 500), with `total_tasks` and, while more remain, `next_offset` |
-| `update_tasks` | `project_id`, `task_ids[]` (≤ 200), any of `assignee_user_id`, `priority`, `story_points`, `cycle`, `start_date`, `end_date`, `add_labels[]`, `remove_labels[]` | Edits planning fields on every task given. A field left out is left alone; `null` clears it. The assignee must be an org member who can open the project. All or nothing: an unknown id fails the call. Returns the tasks as they are now |
-| `set_task_status` | `project_id`, `task_ids[]` (≤ 200), `status` | Rewrites the tasks' checkboxes in tasks.md (`[ ]`, `[-]`, `[x]`), one revision per file, recorded as an AI change. Partial: returns `updated`/`unchanged`/`removed`/`failed` counts, an outcome per task (with an error code such as `conflict` or `quota_exceeded`) and per file, and the tasks as they are now; an error result only when every task failed |
+| `list_tasks` | `project_id`, optional `status`, `assignee_user_id` (a user id, `me` or `none`), `cycle`, `label`, `file_id`, `include_details`, `limit`, `offset` | The project's task board: every checkbox task in its tasks.md files, in file order, each with a stable `task_id`, `status` (`pending`/`in_progress`/`done`), assignee, `priority` (0 none … 4 low, plus `priority_name`), `story_points`, `cycle`, `start_date`/`end_date` (calendar days, `YYYY-MM-DD`), `labels`, and with `include_details` a 500-character preview of its details. Also the files (with the `content_version` their tasks reflect) and the labels and cycles in use. Filtered and paged by the platform: 100 tasks by default (`limit` up to 500), with `total_tasks` and, while more remain, `next_offset` |
+| `list_task_assignees` | `project_id` | Who the project's tasks can be assigned to: the org's people who can open the project (exactly who `update_tasks` accepts), each with `user_id`, `username` and `display_name`, plus your own `self_user_id`. May include people who left the org but whose profile remains; at most 1000 (`truncated`) |
+| `update_tasks` | `project_id`, `task_ids[]` (≤ 200), any of `assignee_user_id`, `priority`, `story_points`, `cycle`, `start_date`, `end_date`, `add_labels[]`, `remove_labels[]` | Edits planning fields on every task given. A field left out is left alone; `null` clears it. The assignee must be an org member who can open the project (`list_task_assignees`); `me` means you. All or nothing: an unknown id fails the call. Returns the tasks as they are now |
+| `set_task_status` | `project_id`, `task_ids[]` (≤ 200), `status`, optional `expected_versions[]` (`{spec_file_id, content_version}` from `list_tasks`) | Rewrites the tasks' checkboxes in tasks.md (`[ ]`, `[-]`, `[x]`), one revision per file, recorded as an AI change. A file that changed since the pinned version is not written (`file_changed`). Partial: returns `updated`/`unchanged`/`removed`/`failed` counts, an outcome per task (with an error code such as `conflict` or `quota_exceeded`) and per file, and the tasks as they are now; an error result only when every task failed |
 
 There is deliberately **no tool to resolve, unresolve or re-anchor a thread**. Those three are human-only: resolving declares a review finished, and re-anchoring is the repair a person makes after the automatic pass has already failed to locate the passage. The platform refuses them for an AI caller with a 403, so a tool would only ever return an error.
 

package/dist/index.js

@@ -1841,6 +1841,24 @@ function isProjectPermissionDeniedError(err) {
   const message = err.message;
   return typeof message === "string" && message.includes("PROJECT_PERMISSION_DENIED:");
 }
+var TASK_BOARD_DISABLED_CODE = "task_board_disabled";
+var PlatformTaskBoardDisabledError = class extends PlatformHttpError {
+  code = TASK_BOARD_DISABLED_CODE;
+  constructor(message, details) {
+    super(message, 403, details);
+    this.name = "PlatformTaskBoardDisabledError";
+  }
+};
+function isTaskBoardDisabledError(err) {
+  if (err instanceof PlatformTaskBoardDisabledError) {
+    return true;
+  }
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const code = err.code;
+  return typeof code === "string" && code.toLowerCase() === TASK_BOARD_DISABLED_CODE;
+}
 function isPlatformHttpError(err) {
   return typeof err === "object" && err !== null && err[PLATFORM_ERROR_BRAND] === true;
 }
@@ -1933,6 +1951,9 @@ function createPlatformError(message, status, details, code) {
   if (status === 403 && typeof code === "string" && code.toLowerCase() === PROJECT_PERMISSION_DENIED_CODE) {
     return new PlatformPermissionError(message, details);
   }
+  if (status === 403 && typeof code === "string" && code.toLowerCase() === TASK_BOARD_DISABLED_CODE) {
+    return new PlatformTaskBoardDisabledError(message, details);
+  }
   return new PlatformHttpError(message, status, details);
 }
 function truncate(text) {
@@ -1958,6 +1979,23 @@ async function throwFromResponse(response, fallbackMessage) {
   throw createPlatformError(`HTTP ${response.status}: ${message}`, response.status, details, code);
 }
 
+// ../../packages/platform-client/shared/jwt.ts
+function jwtSubject(token) {
+  const raw = token.startsWith("Bearer ") ? token.slice("Bearer ".length) : token;
+  const payloadSegment = raw.split(".")[1];
+  if (!payloadSegment) {
+    return null;
+  }
+  try {
+    const base64 = payloadSegment.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const payload = JSON.parse(atob(padded));
+    return typeof payload.sub === "string" && payload.sub !== "" ? payload.sub : null;
+  } catch {
+    return null;
+  }
+}
+
 // ../../packages/shared/logger.ts
 var LOG_LEVEL_PRIORITY = {
   debug: 0,
@@ -2325,7 +2363,12 @@ var TASK_LIMITS = {
   maxLabels: 20,
   maxLabelLength: 40,
   maxStoryPoints: 9999.99,
-  maxTasksPerRequest: 200
+  maxCycle: 1e5,
+  maxTasksPerRequest: 200,
+  /** The most tasks one page of a listing holds. */
+  maxPageSize: 500,
+  /** The most tasks.md files one board lists (and the most expected_versions a status change takes). */
+  maxBoardFiles: 500
 };
 function parseTimestamp(raw) {
   if (!raw) return null;
@@ -2380,9 +2423,31 @@ function transformTaskBoard(raw) {
     })),
     tasks: (raw.tasks ?? []).map(transformProjectTask),
     labels: raw.labels ?? [],
-    cycles: raw.cycles ?? []
+    cycles: raw.cycles ?? [],
+    filesTruncated: raw.files_truncated === true,
+    ...typeof raw.total === "number" ? {
+      page: {
+        total: raw.total,
+        offset: raw.offset ?? 0,
+        limit: raw.limit ?? 0,
+        nextOffset: typeof raw.next_offset === "number" ? raw.next_offset : null
+      }
+    } : {}
   };
 }
+function toTaskListQueryString(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  if (query.status) params.set("status", query.status);
+  if (query.assigneeUserId) params.set("assignee_user_id", query.assigneeUserId);
+  if (query.cycle !== void 0) params.set("cycle", String(query.cycle));
+  if (query.label) params.set("label", query.label);
+  if (query.specFileId) params.set("spec_file_id", query.specFileId);
+  if (query.limit !== void 0) params.set("limit", String(query.limit));
+  if (query.offset !== void 0) params.set("offset", String(query.offset));
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
 function transformSetTaskStatusResult(raw) {
   return {
     results: (raw.results ?? []).map((r) => ({
@@ -2399,6 +2464,17 @@ function transformSetTaskStatusResult(raw) {
     tasks: (raw.tasks ?? []).map(transformProjectTask)
   };
 }
+function transformTaskAssigneeList(raw) {
+  return {
+    assignees: (raw.assignees ?? []).map((a) => ({
+      userId: a.user_id,
+      username: a.username ?? "",
+      displayName: a.display_name ?? ""
+    })),
+    selfUserId: raw.self_user_id ?? "",
+    truncated: raw.truncated === true
+  };
+}
 function toRawUpdateTasksRequest(taskIds, patch) {
   const set = {};
   if ("assigneeUserId" in patch) set.assignee_user_id = patch.assigneeUserId ?? null;
@@ -3257,10 +3333,18 @@ var HttpProjectTaskClient = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
-  async listProjectTasks(projectId, jwtToken) {
-    const raw = await this.httpClient.get(tasksPath(projectId), jwtToken, {});
+  async listProjectTasks(projectId, jwtToken, query) {
+    const raw = await this.httpClient.get(
+      `${tasksPath(projectId)}${toTaskListQueryString(query)}`,
+      jwtToken,
+      {}
+    );
     return transformTaskBoard(raw);
   }
+  async listProjectTaskAssignees(projectId, jwtToken) {
+    const raw = await this.httpClient.get(`${tasksPath(projectId)}/assignees`, jwtToken, {});
+    return transformTaskAssigneeList(raw);
+  }
   async updateProjectTasks(projectId, taskIds, patch, jwtToken) {
     const raw = await this.httpClient.patch(
       tasksPath(projectId),
@@ -3271,9 +3355,16 @@ var HttpProjectTaskClient = class {
     return (raw.tasks ?? []).map(transformProjectTask);
   }
   async setProjectTaskStatus(projectId, taskIds, status, jwtToken, opts) {
+    const body = {
+      task_ids: taskIds,
+      status
+    };
+    if (opts?.expectedVersions && Object.keys(opts.expectedVersions).length > 0) {
+      body.expected_versions = opts.expectedVersions;
+    }
     const raw = await this.httpClient.post(
       `${tasksPath(projectId)}/status`,
-      { task_ids: taskIds, status },
+      body,
       jwtToken,
       opts?.actorKind ? { headers: { [HEADER_ACTOR_KIND3]: opts.actorKind } } : {}
     );
@@ -4108,18 +4199,33 @@ var PlatformClient = class {
   // `actorKind: 'ai'` like every other file write here: the revision is then
   // recorded as the assistant's, not filed under the user's name. A planning
   // edit writes no file and the platform records no actor kind for it.
-  /** Every live task of a project's tasks.md files. */
-  async listProjectTasks(projectId) {
-    return this.withTokenRetry((jwt, c) => c.task.listProjectTasks(projectId, jwt));
+  /** The live tasks of a project's tasks.md files: all, or those `query` keeps. */
+  async listProjectTasks(projectId, query) {
+    return this.withTokenRetry((jwt, c) => c.task.listProjectTasks(projectId, jwt, query));
+  }
+  /** Who the project's tasks can be assigned to, and the caller's own user id. */
+  async listProjectTaskAssignees(projectId) {
+    return this.withTokenRetry((jwt, c) => c.task.listProjectTaskAssignees(projectId, jwt));
+  }
+  /**
+   * The caller's own user id, read from the access token (unverified: only to
+   * turn "me" into an id the platform then checks). Null when the token does
+   * not carry one.
+   */
+  async currentUserId() {
+    return jwtSubject(await this.tokenManager.getValidAccessToken());
   }
   /** Applies one planning patch to up to 200 tasks; all or nothing. */
   async updateProjectTasks(projectId, taskIds, patch) {
     return this.withTokenRetry((jwt, c) => c.task.updateProjectTasks(projectId, taskIds, patch, jwt));
   }
-  /** Sets the status of up to 200 tasks by rewriting their checkboxes. */
-  async setProjectTaskStatus(projectId, taskIds, status) {
+  /**
+   * Sets the status of up to 200 tasks by rewriting their checkboxes.
+   * `expectedVersions` pins the file versions the caller's view came from.
+   */
+  async setProjectTaskStatus(projectId, taskIds, status, expectedVersions) {
     return this.withTokenRetry(
-      (jwt, c) => c.task.setProjectTaskStatus(projectId, taskIds, status, jwt, { actorKind: "ai" })
+      (jwt, c) => c.task.setProjectTaskStatus(projectId, taskIds, status, jwt, { actorKind: "ai", expectedVersions })
     );
   }
   async withTokenRetry(call) {
@@ -7334,8 +7440,10 @@ var startSpecSessionTool = {
 import { z as z39 } from "zod";
 var LIST_DEFAULT_TASKS = 100;
 var LIST_MAX_TASKS = 500;
+var LIST_MAX_OFFSET = 1e6;
 var DETAILS_PREVIEW_CHARS = 500;
-var MAX_CYCLE = 1e5;
+var ME = "me";
+var NONE = "none";
 var PRIORITY_NAMES = ["none", "urgent", "high", "medium", "low"];
 var STATUS = z39.enum(["pending", "in_progress", "done"]);
 function toDay(date) {
@@ -7371,6 +7479,10 @@ function taskSummary(task, opts = {}) {
   };
 }
 var userIdField = z39.string().trim().min(1);
+async function resolveMe(id, ctx) {
+  return id === ME ? ctx.client.currentUserId() : id;
+}
+var UNKNOWN_ME = 'Could not tell who you are from this connection, so "me" cannot be used. Pass your user id instead: list_task_assignees returns it as self_user_id.';
 var labelField = z39.string().trim().min(1).refine((label) => Array.from(label).length <= TASK_LIMITS.maxLabelLength, {
   message: `A label is at most ${String(TASK_LIMITS.maxLabelLength)} characters.`
 });
@@ -7380,8 +7492,10 @@ function taskIdsField(what) {
 var listInputSchema2 = {
   project_id: z39.uuid().describe("UUID of the project whose tasks to list."),
   status: STATUS.optional().describe("Only tasks with this status."),
-  assignee_user_id: userIdField.optional().describe("Only tasks assigned to this user id (as returned in assignee_user_id)."),
-  cycle: z39.number().int().min(1).optional().describe("Only tasks in this cycle (sprint) number."),
+  assignee_user_id: userIdField.optional().describe(
+    'Only tasks assigned to this user id (as returned in assignee_user_id or by list_task_assignees). "me" means you; "none" means unassigned tasks.'
+  ),
+  cycle: z39.number().int().min(1).max(TASK_LIMITS.maxCycle).optional().describe("Only tasks in this cycle (sprint) number."),
   label: labelField.optional().describe("Only tasks carrying this label."),
   file_id: z39.uuid().optional().describe("Only tasks from this tasks.md (its spec file id)."),
   include_details: z39.boolean().optional().describe(
@@ -7390,20 +7504,51 @@ var listInputSchema2 = {
   limit: z39.number().int().min(1).max(LIST_MAX_TASKS).optional().describe(
     `Tasks per page (default ${String(LIST_DEFAULT_TASKS)}, at most ${String(LIST_MAX_TASKS)}).`
   ),
-  offset: z39.number().int().min(0).optional().describe("How many matching tasks to skip; pass next_offset from the previous page.")
+  offset: z39.number().int().min(0).max(LIST_MAX_OFFSET).optional().describe("How many matching tasks to skip; pass next_offset from the previous page.")
 };
+function pageLocally(board, query) {
+  const assignee = query.assigneeUserId;
+  const label = query.label?.split(/\s+/).filter(Boolean).join(" ");
+  const matching = board.tasks.filter(
+    (task) => (query.status === void 0 || task.status === query.status) && (assignee === void 0 || (assignee === NONE ? task.assigneeUserId === null : task.assigneeUserId === assignee)) && (query.cycle === void 0 || task.cycle === query.cycle) && (label === void 0 || task.labels.includes(label)) && (query.specFileId === void 0 || task.specFileId === query.specFileId)
+  );
+  const offset = query.offset ?? 0;
+  const tasks = matching.slice(offset, offset + (query.limit ?? LIST_DEFAULT_TASKS));
+  const next = offset + tasks.length;
+  return {
+    tasks,
+    total: matching.length,
+    offset,
+    nextOffset: next < matching.length ? next : null
+  };
+}
 var listTasksTool = {
   name: "list_tasks",
-  description: "List a project's tasks: every checkbox task in its tasks.md files, in file order, each with a stable task_id, status (pending, in_progress, done), assignee, priority (0 none, 1 urgent, 2 high, 3 medium, 4 low), story points, cycle, start/end dates (YYYY-MM-DD) and labels. Also returns the files, and the labels and cycles in use. Filter by status, assignee, cycle, label or file. Paged: 100 tasks by default (limit up to 500), with total_tasks and, while more remain, next_offset. Details (sub-bullets) only with include_details. Use the task_id values with update_tasks and set_task_status.",
+  description: `List a project's tasks: every checkbox task in its tasks.md files, in file order, each with a stable task_id, status (pending, in_progress, done), assignee, priority (0 none, 1 urgent, 2 high, 3 medium, 4 low), story points, cycle, start/end dates (YYYY-MM-DD) and labels. Also returns the files (with the content_version their tasks reflect), and the labels and cycles in use. Filter by status, assignee ("me" for yourself, "none" for unassigned), cycle, label or file. Paged: 100 tasks by default (limit up to 500), with total_tasks and, while more remain, next_offset. Details (sub-bullets) only with include_details. Use the task_id values with update_tasks and set_task_status.`,
   inputSchema: listInputSchema2,
   handler: async (args, ctx) => {
-    const board = await ctx.client.listProjectTasks(args.project_id);
-    const matching = board.tasks.filter(
-      (task) => (args.status === void 0 || task.status === args.status) && (args.assignee_user_id === void 0 || task.assigneeUserId === args.assignee_user_id) && (args.cycle === void 0 || task.cycle === args.cycle) && (args.label === void 0 || task.labels.includes(args.label)) && (args.file_id === void 0 || task.specFileId === args.file_id)
-    );
-    const offset = args.offset ?? 0;
-    const page = matching.slice(offset, offset + (args.limit ?? LIST_DEFAULT_TASKS));
-    const next = offset + page.length;
+    let assignee;
+    if (args.assignee_user_id !== void 0) {
+      const resolved = await resolveMe(args.assignee_user_id, ctx);
+      if (resolved === null) return errorResult(UNKNOWN_ME);
+      assignee = resolved;
+    }
+    const query = {
+      ...args.status !== void 0 ? { status: args.status } : {},
+      ...assignee !== void 0 ? { assigneeUserId: assignee } : {},
+      ...args.cycle !== void 0 ? { cycle: args.cycle } : {},
+      ...args.label !== void 0 ? { label: args.label } : {},
+      ...args.file_id !== void 0 ? { specFileId: args.file_id } : {},
+      limit: args.limit ?? LIST_DEFAULT_TASKS,
+      offset: args.offset ?? 0
+    };
+    const board = await ctx.client.listProjectTasks(args.project_id, query);
+    const page = board.page ? {
+      tasks: board.tasks,
+      total: board.page.total,
+      offset: board.page.offset,
+      nextOffset: board.page.nextOffset
+    } : pageLocally(board, query);
     return jsonResult({
       project_id: board.projectId,
       files: board.files.map((file) => ({
@@ -7413,25 +7558,49 @@ var listTasksTool = {
         // The file could not be re-read just now: its tasks are from the last read.
         ...file.stale ? { stale: true } : {}
       })),
-      tasks: page.map((task) => taskSummary(task, { details: args.include_details })),
-      total_tasks: matching.length,
-      offset,
+      // Only ever present and true: the project has more than 500 tasks.md
+      // files and the rest are left out.
+      ...board.filesTruncated ? { files_truncated: true } : {},
+      tasks: page.tasks.map((task) => taskSummary(task, { details: args.include_details })),
+      total_tasks: page.total,
+      offset: page.offset,
       // Only while more remain, so its absence means "that was the last page".
-      ...next < matching.length ? { next_offset: next } : {},
+      ...page.nextOffset !== null ? { next_offset: page.nextOffset } : {},
       labels: board.labels,
       cycles: board.cycles
     });
   }
 };
+var assigneesInputSchema = {
+  project_id: z39.uuid().describe("UUID of the project whose tasks are being assigned.")
+};
+var listTaskAssigneesTool = {
+  name: "list_task_assignees",
+  description: `List who a project's tasks can be assigned to: the organisation's people who can open the project, which is exactly who update_tasks accepts as assignee_user_id. Each has a user_id, a username (handle) and a display_name ("" when unset). Also returns your own user id as self_user_id. May include people who have left the organisation but whose profile remains. At most 1000 people; truncated is true when the list was cut.`,
+  inputSchema: assigneesInputSchema,
+  handler: async (args, ctx) => {
+    const list = await ctx.client.listProjectTaskAssignees(args.project_id);
+    return jsonResult({
+      assignees: list.assignees.map((a) => ({
+        user_id: a.userId,
+        username: a.username,
+        display_name: a.displayName
+      })),
+      self_user_id: list.selfUserId,
+      // Only ever present and true.
+      ...list.truncated ? { truncated: true } : {}
+    });
+  }
+};
 var updateInputSchema2 = {
   project_id: z39.uuid().describe("UUID of the project the tasks belong to."),
   task_ids: taskIdsField("The tasks to change (task_id values from list_tasks)."),
   assignee_user_id: userIdField.nullable().optional().describe(
-    "User id to assign, or null to unassign. The person must be a member of the organisation who can open the project."
+    'User id to assign ("me" for yourself), or null to unassign. The person must be a member of the organisation who can open the project: list_task_assignees lists them.'
   ),
   priority: z39.number().int().min(0).max(4).optional().describe("0 none, 1 urgent, 2 high, 3 medium, 4 low."),
   story_points: z39.number().min(0).max(TASK_LIMITS.maxStoryPoints).nullable().optional().describe("Estimate in story points, or null to clear it."),
-  cycle: z39.number().int().min(1).max(MAX_CYCLE).nullable().optional().describe("Cycle (sprint) number, or null to clear it."),
+  cycle: z39.number().int().min(1).max(TASK_LIMITS.maxCycle).nullable().optional().describe("Cycle (sprint) number, or null to clear it."),
   start_date: z39.iso.date().nullable().optional().describe("Start day as YYYY-MM-DD, or null to clear it."),
   end_date: z39.iso.date().nullable().optional().describe("Due day as YYYY-MM-DD, or null to clear it. Not before the start day."),
   add_labels: z39.array(labelField).max(TASK_LIMITS.maxLabels).optional().describe(`Labels to add. A task carries at most ${String(TASK_LIMITS.maxLabels)}.`),
@@ -7443,7 +7612,13 @@ var updateTasksTool = {
   inputSchema: updateInputSchema2,
   handler: async (args, ctx) => {
     const patch = {};
-    if (args.assignee_user_id !== void 0) patch.assigneeUserId = args.assignee_user_id;
+    if (args.assignee_user_id === null) {
+      patch.assigneeUserId = null;
+    } else if (args.assignee_user_id !== void 0) {
+      const assignee = await resolveMe(args.assignee_user_id, ctx);
+      if (assignee === null) return errorResult(UNKNOWN_ME);
+      patch.assigneeUserId = assignee;
+    }
     if (args.priority !== void 0) patch.priority = args.priority;
     if (args.story_points !== void 0) patch.storyPoints = args.story_points;
     if (args.cycle !== void 0) patch.cycle = args.cycle;
@@ -7467,17 +7642,27 @@ var updateTasksTool = {
 var statusInputSchema = {
   project_id: z39.uuid().describe("UUID of the project the tasks belong to."),
   task_ids: taskIdsField("The tasks to move (task_id values from list_tasks)."),
-  status: STATUS.describe("The new status: pending, in_progress or done.")
+  status: STATUS.describe("The new status: pending, in_progress or done."),
+  expected_versions: z39.array(
+    z39.object({
+      spec_file_id: z39.uuid().describe("A tasks.md file (spec_file_id from list_tasks)."),
+      content_version: z39.number().int().min(0).describe("The content_version list_tasks returned for that file.")
+    })
+  ).max(TASK_LIMITS.maxBoardFiles).optional().describe(
+    "Optional. The file versions your view of these tasks came from (from list_tasks); only the files these tasks are in are checked, so passing just those is enough. A file that has changed since is not written and its tasks fail with file_changed, so a change never lands on a line you did not see; list again and retry."
+  )
 };
 var setTaskStatusTool = {
   name: "set_task_status",
-  description: "Change the status of one or more tasks by rewriting their checkbox in the project's tasks.md files: `[ ]` pending, `[-]` in progress, `[x]` done. Each affected file gets one new revision, recorded as an AI change; nothing else in the file changes. Partial by nature: a file that cannot be written (it kept changing, the organisation is out of storage, or it was moved to the trash) fails only its own tasks. Returns an outcome per task (updated, unchanged, removed: no longer in its file, failed: with an error code), an outcome per file, and the tasks as they are now. Marked as an error only when every task failed.",
+  description: "Change the status of one or more tasks by rewriting their checkbox in the project's tasks.md files: `[ ]` pending, `[-]` in progress, `[x]` done. Each affected file gets one new revision, recorded as an AI change; nothing else in the file changes. Partial by nature: a file that cannot be written (it kept changing, it changed since the expected_versions you passed, the organisation is out of storage, or it was moved to the trash) fails only its own tasks. Returns an outcome per task (updated, unchanged, removed: no longer in its file, failed: with an error code), an outcome per file, and the tasks as they are now. Marked as an error only when every task failed.",
   inputSchema: statusInputSchema,
   handler: async (args, ctx) => {
+    const expected = args.expected_versions?.length ? Object.fromEntries(args.expected_versions.map((v) => [v.spec_file_id, v.content_version])) : void 0;
     const result = await ctx.client.setProjectTaskStatus(
       args.project_id,
       args.task_ids,
-      args.status
+      args.status,
+      expected
     );
     const count = (outcome) => result.results.filter((r) => r.outcome === outcome).length;
     const failed = count("failed");
@@ -7555,6 +7740,7 @@ function buildServer(deps) {
   registerTool(server, updateSpecFileCommentTool, ctx);
   registerTool(server, deleteSpecFileCommentTool, ctx);
   registerTool(server, listTasksTool, ctx);
+  registerTool(server, listTaskAssigneesTool, ctx);
   registerTool(server, updateTasksTool, ctx);
   registerTool(server, setTaskStatusTool, ctx);
   return server;
@@ -7575,6 +7761,11 @@ function wrapToolHandler(tool, ctx) {
       if (isProjectPermissionDeniedError(err)) {
         return errorResult(`${tool.name} failed: ${permissionDeniedMessage(err)}`);
       }
+      if (isTaskBoardDisabledError(err)) {
+        return errorResult(
+          `${tool.name} failed: the task board is turned off in this MySpec environment, so the task tools are unavailable here until it is turned on.`
+        );
+      }
       const message = err instanceof Error ? err.message : String(err);
       return errorResult(`${tool.name} failed: ${message}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myspec/mcp-server",
-  "version": "1.1.1-next.165",
+  "version": "1.1.1-next.166",
   "description": "MySpec MCP server — exposes MySpec platform projects, files and attachments to MCP-aware clients via OAuth-authenticated access tokens.",
   "type": "module",
   "repository": {