@omnicoreos/planka-mcp 0.2.0 → 0.3.0

package/tests/smoke/planka-smoke.mjs

@@ -37,7 +37,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { PlankaApi, boardEntities } from "../../scripts/lib/planka-api.mjs";
 
-const EXPECTED_TOOL_COUNT = 24;
+const EXPECTED_TOOL_COUNT = 41;
 
 /** Prefix on every artifact this test creates; the initial sweep looks for it. */
 const PREFIX = "[smoke planka-mcp]";
@@ -287,15 +287,19 @@ async function run() {
   const boardText = JSON.stringify(mcpBoard);
 
   // --- labels the scratch card will carry -----------------------------------
-  const labelA = await json("planka_manage_labels", {
-    action: "create",
+  const labelA = await json("planka_create_label", {
     boardId,
     name: `${PREFIX} A`,
     color: "berry-red",
   });
   if (labelA?.label?.id) artifacts.labels.push(labelA.label.id);
-  check("planka_manage_labels create (A)", Boolean(labelA?.label?.id), labelA);
+  check(
+    "planka_create_label (A) reports verified: true",
+    Boolean(labelA?.label?.id) && labelA.verified === true,
+    labelA
+  );
 
+  // The one deprecated-alias check for labels: the old name must still route.
   const labelB = await json("planka_manage_labels", {
     action: "create",
     boardId,
@@ -303,21 +307,24 @@ async function run() {
     color: "lagoon-blue",
   });
   if (labelB?.label?.id) artifacts.labels.push(labelB.label.id);
-  check("planka_manage_labels create (B)", Boolean(labelB?.label?.id), labelB);
+  check(
+    "planka_manage_labels (DEPRECATED alias) still creates, verified: true",
+    Boolean(labelB?.label?.id) && labelB.verified === true,
+    labelB
+  );
 
   if (!labelA?.label?.id || !labelB?.label?.id) {
     throw new Error("Without labels there is no smoke — stopping here");
   }
 
-  const renamed = await json("planka_manage_labels", {
-    action: "update",
+  const renamed = await json("planka_update_label", {
     labelId: labelA.label.id,
     name: `${PREFIX} A2`,
     color: "pumpkin-orange",
   });
   check(
-    "planka_manage_labels update renames and recolors",
-    renamed?.label?.name === `${PREFIX} A2`,
+    "planka_update_label renames and recolors, verified: true",
+    renamed?.label?.name === `${PREFIX} A2` && renamed.verified === true,
     renamed
   );
 
@@ -332,8 +339,11 @@ async function run() {
   const cardId = created?.card?.id;
   if (cardId) artifacts.cards.push(cardId);
   check(
-    "planka_create_card creates a card with 2 tasks and 1 label",
-    Boolean(cardId) && created.tasksCreated === 2 && created.labelsAttached === 1,
+    "planka_create_card creates a card with 2 tasks and 1 label, verified: true",
+    Boolean(cardId) &&
+      created.verified === true &&
+      created.tasksCreated === 2 &&
+      created.labelsAttached === 1,
     created
   );
   if (!cardId) throw new Error("Without a card there is no smoke — stopping here");
@@ -345,44 +355,96 @@ async function run() {
     cardId
   );
 
-  const details = await json("planka_get_card", { cardId });
+  // detail:"full" is what carries the task items and the whole description;
+  // the default digest returns counts and a 200-char preview.
+  const details = await json("planka_get_card", { cardId, detail: "full" });
   check(
     "planka_get_card returns the name, both tasks and the label",
     details?.card?.name === CARD_NAME &&
-      details?.tasks?.length === 2 &&
+      details?.tasks?.total === 2 &&
+      details?.tasks?.lists?.[0]?.items?.length === 2 &&
       details?.labels?.length === 1,
     details
   );
-  const taskId = details?.tasks?.[0]?.id;
+  const taskId = details?.tasks?.lists?.[0]?.items?.[0]?.id;
 
-  const updated = await callTool("planka_update_card", {
+  const digest = await json("planka_get_card", { cardId });
+  check(
+    "the digest counts the tasks without listing them, and reads no comments",
+    digest?.detail === "digest" &&
+      digest?.tasks?.total === 2 &&
+      digest?.tasks?.lists?.[0]?.items === undefined &&
+      !Array.isArray(digest?.comments),
+    digest
+  );
+
+  const updated = await json("planka_update_card", {
     cardId,
     description: "description updated by the smoke test",
   });
-  check("planka_update_card updates the description", !updated.isError, updated.text);
+  check(
+    "planka_update_card updates the description, verified: true",
+    updated?.verified === true,
+    updated
+  );
 
-  const reread = await json("planka_get_card", { cardId });
+  const reread = await json("planka_get_card", { cardId, detail: "full" });
   check(
     "the update persisted (verified by re-reading)",
     reread?.card?.description === "description updated by the smoke test",
     reread?.card?.description
   );
 
-  const taskUpdated = await callTool("planka_update_task", {
+  const taskUpdated = await json("planka_update_task", {
     taskId,
+    cardId,
     isCompleted: true,
     name: "first (done)",
   });
-  check("planka_update_task completes and renames", !taskUpdated.isError, taskUpdated.text);
+  check(
+    "planka_update_task completes and renames, verified against the card",
+    taskUpdated?.verified === true && taskUpdated.task?.isCompleted === true,
+    taskUpdated
+  );
+
+  // A write that cannot be verified is NOT a success: no cardId means the task
+  // cannot be re-read, and the payload has to say so instead of claiming it.
+  const unverifiable = await callTool("planka_update_task", {
+    taskId,
+    name: "first (done)",
+  });
+  const unverifiableBody = (() => {
+    try {
+      return JSON.parse(unverifiable.text);
+    } catch {
+      return null;
+    }
+  })();
+  check(
+    "planka_update_task without cardId answers success:false, not a false green",
+    unverifiable.isError === true &&
+      unverifiableBody?.success === false &&
+      unverifiableBody?.verified === false &&
+      String(unverifiableBody?.verificationUnavailable ?? "").includes("cardId"),
+    unverifiableBody ?? unverifiable.text
+  );
 
-  const taskAdded = await callTool("planka_create_tasks", {
+  const taskAdded = await json("planka_create_tasks", {
     cardId,
     tasks: ["third"],
   });
-  check("planka_create_tasks appends a task", !taskAdded.isError, taskAdded.text);
+  check(
+    "planka_create_tasks appends a task, verified: true",
+    taskAdded?.verified === true && taskAdded.tasksCreated === 1,
+    taskAdded
+  );
 
-  const taskDeleted = await callTool("planka_delete_task", { taskId });
-  check("planka_delete_task removes the task", !taskDeleted.isError, taskDeleted.text);
+  const taskDeleted = await json("planka_delete_task", { taskId, cardId });
+  check(
+    "planka_delete_task removes the task, verified against the card",
+    taskDeleted?.verified === true,
+    taskDeleted
+  );
 
   // --- labels on the card ---------------------------------------------------
   const swapped = await json("planka_set_card_labels", {
@@ -418,7 +480,7 @@ async function run() {
   });
   check(
     "planka_list_cards with labelFilter finds the card",
-    filtered?.cards?.some((card) => card.id === cardId),
+    filtered?.matches?.some((card) => card.id === cardId),
     filtered
   );
 
@@ -436,6 +498,16 @@ async function run() {
     allCards
   );
 
+  // The list show answers the whole column in one request: `truncated` is
+  // false by construction and `total` is the real size of the column.
+  check(
+    "planka_find_cards with listId reads the column whole, not a page of it",
+    allCards?.source === "list" &&
+      allCards?.truncated === false &&
+      allCards?.list?.id === list.id,
+    allCards
+  );
+
   const rawListCards = await api.get(`/api/lists/${list.id}/cards`);
   check(
     "the count matches the raw API (or exceeds one page, which is the point)",
@@ -443,10 +515,18 @@ async function run() {
     `mcp total=${totalInList} · raw first page=${rawListCards.items?.length}`
   );
 
+  // Cross-check against the list show, which carries every card of the column.
+  const rawListShow = await api.get(`/api/lists/${list.id}`);
+  check(
+    "planka_find_cards total equals the real size of the column (raw list show)",
+    totalInList === (rawListShow.included?.cards?.length ?? -1),
+    `mcp total=${totalInList} · raw list show=${rawListShow.included?.cards?.length}`
+  );
+
   check(
     "planka_list_cards omits descriptions by default",
-    allCards?.cards?.every((card) => card.description === undefined),
-    allCards?.cards?.[0]
+    allCards?.matches?.every((card) => card.description === undefined),
+    allCards?.matches?.[0]
   );
 
   const page = await json("planka_list_cards", {
@@ -474,7 +554,7 @@ async function run() {
       "planka_list_cards with an offset returns the next card, not the same one",
       next?.returned === 1 &&
         next.offset === 1 &&
-        next.cards[0].id !== page.cards[0].id,
+        next.matches[0].id !== page.matches[0].id,
       next
     );
   } else {
@@ -495,6 +575,23 @@ async function run() {
     lists
   );
 
+  check(
+    "planka_board_summary warns instead of answering an empty cardsFrom",
+    await (async () => {
+      const typo = await json("planka_board_summary", {
+        boardId,
+        cardsFrom: [`${PREFIX} no such column`],
+      });
+      return (
+        Array.isArray(typo?.warnings) &&
+        typo.warnings.join(" ").includes(`${PREFIX} no such column`) &&
+        typo.warnings.join(" ").includes(list.name) &&
+        (typo.cards === undefined || typo.cards.length === 0)
+      );
+    })(),
+    "cardsFrom typo must come back as a warning, never as an empty column"
+  );
+
   check(
     "planka_list_lists is far cheaper than planka_get_board",
     JSON.stringify(lists).length * 4 < boardText.length,
@@ -554,10 +651,20 @@ async function run() {
     "planka_find_cards by label returns exactly the labelled card",
     byLabel?.total === 1 &&
       byLabel.matches[0].id === cardId &&
-      byLabel.matches[0].list === list.name,
+      byLabel.matches[0].listId === list.id &&
+      byLabel.matches[0].listName === list.name,
     byLabel
   );
 
+  // The digest carries the label IDs, not only the names: set_card_labels takes
+  // ids, and a digest without them sent the caller back to board_summary.
+  check(
+    "planka_find_cards digest carries labelIds, so set_card_labels can run on it",
+    Array.isArray(byLabel?.matches?.[0]?.labelIds) &&
+      byLabel.matches[0].labelIds.includes(labelB.label.id),
+    byLabel?.matches?.[0]
+  );
+
   // The description was written by the update above and is NOT in the name:
   // if this matches, the text search really is reading descriptions.
   const byText = await json("planka_find_cards", {
@@ -578,7 +685,8 @@ async function run() {
   check(
     "planka_find_cards with listId stays inside that column",
     scoped?.matches?.length > 0 &&
-      scoped.matches.every((card) => card.listId === list.id),
+      scoped.list?.id === list.id &&
+      scoped.source === "list",
     scoped
   );
 
@@ -589,9 +697,9 @@ async function run() {
   check(
     "planka_find_cards warns when the label does not exist and lists the ones that do",
     noLabel?.total === 0 &&
-      typeof noLabel.warning === "string" &&
-      noLabel.warning.includes(`${PREFIX} B`),
-    noLabel?.warning
+      Array.isArray(noLabel.warnings) &&
+      noLabel.warnings.join(" ").includes(`${PREFIX} B`),
+    noLabel?.warnings
   );
 
   const noFilter = await callTool("planka_find_cards", { boardId });
@@ -601,12 +709,78 @@ async function run() {
     noFilter.text
   );
 
-  const moved = await callTool("planka_move_card", {
+  const moved = await json("planka_move_card", {
     cardId,
     listId: list.id,
     position: 1,
   });
-  check("planka_move_card repositions inside the list", !moved.isError, moved.text);
+  check(
+    "planka_move_card repositions inside the list, verified: true",
+    moved?.verified === true,
+    moved
+  );
+
+  // A move BETWEEN columns is the real use of the tool: a temporary column is
+  // created for it, the card goes there and comes back, and the raw API is the
+  // judge in both directions.
+  const moveTarget = await json("planka_create_list", {
+    boardId,
+    name: `${PREFIX} move target`,
+  });
+  if (moveTarget?.list?.id) artifacts.lists.push(moveTarget.list.id);
+  check(
+    "planka_create_list (move target) reports verified: true",
+    Boolean(moveTarget?.list?.id) && moveTarget.verified === true,
+    moveTarget
+  );
+
+  if (moveTarget?.list?.id) {
+    const movedAcross = await json("planka_move_card", {
+      cardId,
+      listId: moveTarget.list.id,
+    });
+    check(
+      "planka_move_card moves the card to ANOTHER column, verified: true",
+      movedAcross?.verified === true &&
+        movedAcross.card?.listId === moveTarget.list.id,
+      movedAcross
+    );
+
+    const rawAfterMove = await rawBoard();
+    check(
+      "the raw API confirms the card changed column",
+      rawAfterMove.cards.find((item) => item.id === cardId)?.listId ===
+        moveTarget.list.id,
+      rawAfterMove.cards.find((item) => item.id === cardId)?.listId
+    );
+
+    const movedBack = await json("planka_move_card", {
+      cardId,
+      listId: list.id,
+    });
+    check(
+      "planka_move_card brings it back to the original column, verified: true",
+      movedBack?.verified === true && movedBack.card?.listId === list.id,
+      movedBack
+    );
+
+    const rawAfterBack = await rawBoard();
+    check(
+      "the raw API confirms the card is back (and was NOT deleted with the column)",
+      rawAfterBack.cards.find((item) => item.id === cardId)?.listId === list.id,
+      rawAfterBack.cards.find((item) => item.id === cardId)?.listId
+    );
+
+    const droppedTarget = await json("planka_delete_list", {
+      listId: moveTarget.list.id,
+    });
+    if (droppedTarget?.verified === true) forget("lists", moveTarget.list.id);
+    check(
+      "planka_delete_list removes the temporary column, verified: true",
+      droppedTarget?.verified === true,
+      droppedTarget
+    );
+  }
 
   // --- comments: a 0 has to be a REAL 0 -------------------------------------
   const emptyMcp = await json("planka_get_comments", { cardId });
@@ -617,12 +791,16 @@ async function run() {
     `mcp=${emptyMcp?.commentCount} · raw=${emptyRaw.items?.length}`
   );
 
-  const addedComment = await json("planka_add_comment", {
+  const addedComment = await json("planka_create_comment", {
     cardId,
     text: "smoke: original comment",
   });
   const commentId = addedComment?.comment?.id;
-  check("planka_add_comment creates the comment", Boolean(commentId), addedComment);
+  check(
+    "planka_create_comment creates the comment, verified: true",
+    Boolean(commentId) && addedComment.verified === true,
+    addedComment
+  );
 
   const readMcp = await json("planka_get_comments", { cardId });
   check(
@@ -647,12 +825,15 @@ async function run() {
     readMcp?.comments?.[0]
   );
 
-  const editedComment = await callTool("planka_manage_comment", {
-    action: "update",
+  const editedComment = await json("planka_update_comment", {
     commentId,
     text: "smoke: edited comment",
   });
-  check("planka_manage_comment update", !editedComment.isError, editedComment.text);
+  check(
+    "planka_update_comment, verified: true",
+    editedComment?.verified === true,
+    editedComment
+  );
 
   const afterEditMcp = await json("planka_get_comments", { cardId });
   const afterEditRaw = await api.getComments(cardId);
@@ -663,11 +844,12 @@ async function run() {
     `mcp=${afterEditMcp?.comments[0].text} · raw=${afterEditRaw.items[0]?.text}`
   );
 
-  const deletedComment = await callTool("planka_manage_comment", {
-    action: "delete",
-    commentId,
-  });
-  check("planka_manage_comment delete", !deletedComment.isError, deletedComment.text);
+  const deletedComment = await json("planka_delete_comment", { commentId });
+  check(
+    "planka_delete_comment, verified: true",
+    deletedComment?.verified === true,
+    deletedComment
+  );
 
   const afterDeleteMcp = await json("planka_get_comments", { cardId });
   const afterDeleteRaw = await api.getComments(cardId);
@@ -677,6 +859,28 @@ async function run() {
     `mcp=${afterDeleteMcp?.commentCount} · raw=${afterDeleteRaw.items?.length}`
   );
 
+  // The two remaining deprecated aliases, on a throwaway comment: the old
+  // names must keep writing exactly like the tools that replaced them.
+  const aliasComment = await json("planka_add_comment", {
+    cardId,
+    text: "smoke: alias comment",
+  });
+  check(
+    "planka_add_comment (DEPRECATED alias) still creates, verified: true",
+    Boolean(aliasComment?.comment?.id) && aliasComment.verified === true,
+    aliasComment
+  );
+
+  const aliasDeleted = await json("planka_manage_comment", {
+    action: "delete",
+    commentId: aliasComment?.comment?.id,
+  });
+  check(
+    "planka_manage_comment (DEPRECATED alias) still deletes, verified: true",
+    aliasDeleted?.verified === true,
+    aliasDeleted
+  );
+
   // --- attachments: byte-for-byte roundtrip ---------------------------------
   workDir = mkdtempSync(join(tmpdir(), "planka-mcp-smoke-"));
   const filePath = join(workDir, "smoke-payload.txt");
@@ -726,14 +930,15 @@ async function run() {
     viewed.text
   );
 
-  const deletedAttachment = await callTool("planka_delete_attachment", {
+  const deletedAttachment = await json("planka_delete_attachment", {
     attachmentId,
+    cardId,
   });
-  if (!deletedAttachment.isError) forget("attachments", attachmentId);
+  if (deletedAttachment?.verified === true) forget("attachments", attachmentId);
   check(
-    "planka_delete_attachment removes the attachment",
-    !deletedAttachment.isError,
-    deletedAttachment.text
+    "planka_delete_attachment removes the attachment, verified: true",
+    deletedAttachment?.verified === true,
+    deletedAttachment
   );
 
   const afterAttachmentDelete = await json("planka_get_attachments", { cardId });
@@ -744,42 +949,261 @@ async function run() {
   );
 
   // --- board lists ----------------------------------------------------------
-  const tempList = await json("planka_manage_lists", {
-    action: "create",
+  const tempList = await json("planka_create_list", {
     boardId,
     name: `${PREFIX} temporary list`,
   });
   if (tempList?.list?.id) artifacts.lists.push(tempList.list.id);
-  check("planka_manage_lists create", Boolean(tempList?.list?.id), tempList);
+  check(
+    "planka_create_list, verified: true",
+    Boolean(tempList?.list?.id) && tempList.verified === true,
+    tempList
+  );
 
-  const renamedList = await json("planka_manage_lists", {
-    action: "update",
+  const renamedList = await json("planka_update_list", {
     listId: tempList.list.id,
     name: `${PREFIX} renamed list`,
   });
   check(
-    "planka_manage_lists update renames",
-    renamedList?.list?.name === `${PREFIX} renamed list`,
+    "planka_update_list renames, verified: true",
+    renamedList?.list?.name === `${PREFIX} renamed list` &&
+      renamedList.verified === true,
     renamedList
   );
 
-  const deletedList = await callTool("planka_manage_lists", {
+  // A bulk move needs a column of its own, which is exactly what tempList is.
+  const strayCard = await json("planka_create_card", {
+    listId: tempList.list.id,
+    name: `${PREFIX} bulk move passenger`,
+  });
+  if (strayCard?.card?.id) artifacts.cards.push(strayCard.card.id);
+  check(
+    "a card was created in the temporary column for the bulk move",
+    Boolean(strayCard?.card?.id) && strayCard.verified === true,
+    strayCard
+  );
+
+  const bulkMoved = await json("planka_move_list_cards", {
+    fromListId: tempList.list.id,
+    toListId: list.id,
+    boardId,
+  });
+  check(
+    "planka_move_list_cards empties the column and the counts add up",
+    bulkMoved?.verified === true &&
+      bulkMoved?.moved === 1 &&
+      bulkMoved?.fromRemaining === 0,
+    bulkMoved
+  );
+
+  const rawAfterBulk = await api.get(`/api/lists/${tempList.list.id}`);
+  check(
+    "the raw API confirms the temporary column is empty",
+    (rawAfterBulk?.included?.cards ?? []).length === 0,
+    rawAfterBulk?.included?.cards?.length
+  );
+
+  const bulkNoop = await json("planka_move_list_cards", {
+    fromListId: tempList.list.id,
+    toListId: list.id,
+  });
+  check(
+    "planka_move_list_cards on an empty column moves nothing and says so",
+    bulkNoop?.verified === true && bulkNoop?.moved === 0,
+    bulkNoop
+  );
+
+  // The one deprecated-alias check for lists.
+  const deletedList = await json("planka_manage_lists", {
     action: "delete",
     listId: tempList.list.id,
   });
-  if (!deletedList.isError) forget("lists", tempList.list.id);
-  check("planka_manage_lists delete", !deletedList.isError, deletedList.text);
+  if (deletedList?.verified === true) forget("lists", tempList.list.id);
+  check(
+    "planka_manage_lists (DEPRECATED alias) still deletes, verified: true",
+    deletedList?.verified === true,
+    deletedList
+  );
+
+  // --- identity -------------------------------------------------------------
+  const who = await json("planka_whoami", { boardId });
+  check(
+    "planka_whoami names the account and the Planka version",
+    Boolean(who?.user?.id) && typeof who?.plankaVersion === "string",
+    who
+  );
+  check(
+    "planka_whoami reports this session's access policy",
+    who?.policy !== undefined && who?.authMode !== undefined,
+    who?.policy
+  );
+
+  const roster = await json("planka_list_users", { boardId });
+  const agentUser = roster?.users?.find((user) => user.id === who?.user?.id);
+  check(
+    "planka_list_users lists the agent account itself",
+    Boolean(agentUser) && ["instance", "board"].includes(roster?.source),
+    roster
+  );
+  check(
+    "planka_list_users hides emails unless asked",
+    (roster?.users ?? []).every((user) => user.email === undefined),
+    roster?.users?.[0]
+  );
+
+  // --- card members ---------------------------------------------------------
+  const assigned = await json("planka_set_card_members", {
+    cardId,
+    add: [who.user.id],
+  });
+  check(
+    "planka_set_card_members assigns and re-reads the membership",
+    assigned?.verified === true &&
+      assigned?.finalMemberIds?.includes(who.user.id),
+    assigned
+  );
+
+  const rawAssigned = await api.getCard(cardId);
+  check(
+    "the raw API confirms the card membership",
+    (rawAssigned?.included?.cardMemberships ?? []).some(
+      (membership) => membership.userId === who.user.id
+    ),
+    rawAssigned?.included?.cardMemberships
+  );
+
+  const unassigned = await json("planka_set_card_members", {
+    cardId,
+    remove: [who.user.id],
+  });
+  check(
+    "planka_set_card_members unassigns and reports an empty membership",
+    unassigned?.verified === true &&
+      !unassigned?.finalMemberIds?.includes(who.user.id),
+    unassigned
+  );
+
+  const rawUnassigned = await api.getCard(cardId);
+  check(
+    "the raw API confirms the membership is gone",
+    !(rawUnassigned?.included?.cardMemberships ?? []).some(
+      (membership) => membership.userId === who.user.id
+    ),
+    rawUnassigned?.included?.cardMemberships
+  );
+
+  // --- history: the card has been created, moved and assigned by now ---------
+  const history = await json("planka_card_history", { cardId, limit: 10 });
+  check(
+    "planka_card_history returns the events this run generated",
+    (history?.events ?? []).some((event) => event.type === "createCard") &&
+      (history?.events ?? []).some((event) => event.type === "moveCard") &&
+      (history?.events ?? []).some((event) => event.type === "addMemberToCard"),
+    history
+  );
+  check(
+    "planka_card_history summarises each event in one human line",
+    (history?.events ?? []).every(
+      (event) => typeof event.summary === "string" && event.summary.length > 0 && event.at
+    ),
+    history?.events?.[0]
+  );
+
+  const activity = await json("planka_board_activity", { boardId, limit: 20 });
+  const inActivity = (activity?.cards ?? []).find((entry) => entry.cardId === cardId);
+  check(
+    "planka_board_activity groups the scratch card's events under it",
+    Boolean(inActivity) && (inActivity?.events ?? []).length > 0,
+    inActivity
+  );
+
+  // --- duplicate ------------------------------------------------------------
+  const duplicate = await json("planka_duplicate_card", {
+    cardId,
+    name: `${PREFIX} duplicate`,
+  });
+  const duplicateId = duplicate?.card?.id ?? null;
+  if (duplicateId) artifacts.cards.push(duplicateId);
+  check(
+    "planka_duplicate_card creates a verified copy",
+    duplicate?.verified === true &&
+      Boolean(duplicateId) &&
+      duplicate?.card?.name === `${PREFIX} duplicate`,
+    duplicate
+  );
+
+  const rawDuplicate = duplicateId ? await api.getCard(duplicateId) : null;
+  check(
+    "the raw API confirms the copy exists in the same column",
+    rawDuplicate?.item?.listId === duplicate?.card?.listId,
+    rawDuplicate?.item
+  );
+
+  // --- archive and back -----------------------------------------------------
+  const beforeArchive = (await api.getCard(cardId))?.item?.listId;
+  const archived = await json("planka_archive_card", { cardId });
+  check(
+    "planka_archive_card moves the card into the board's archive column",
+    archived?.verified === true && archived?.archived === true,
+    archived
+  );
+
+  const rawArchived = await api.getCard(cardId);
+  check(
+    "the raw API confirms the card left its column",
+    rawArchived?.item?.listId === archived?.archiveListId &&
+      rawArchived?.item?.listId !== beforeArchive,
+    rawArchived?.item
+  );
+
+  const archivedAgain = await json("planka_archive_card", { cardId });
+  check(
+    "archiving an archived card says so instead of moving it again",
+    archivedAgain?.alreadyArchived === true,
+    archivedAgain
+  );
+
+  const restored = await json("planka_archive_card", {
+    cardId,
+    restoreToListId: beforeArchive,
+  });
+  check(
+    "planka_archive_card restores the card to the column it came from",
+    restored?.verified === true && restored?.card?.listId === beforeArchive,
+    restored
+  );
+
+  const rawRestored = await api.getCard(cardId);
+  check(
+    "the raw API confirms the card is back in its column",
+    rawRestored?.item?.listId === beforeArchive,
+    rawRestored?.item
+  );
 
   // --- actionable error paths ----------------------------------------------
-  const errMissing = await callTool("planka_add_comment", { cardId });
+  const errMissing = await callTool("planka_create_comment", { cardId });
   check(
     "ERROR: a missing required field names the tool and the field",
     errMissing.isError &&
       errMissing.text.includes("text") &&
-      errMissing.text.includes("planka_add_comment"),
+      errMissing.text.includes("planka_create_comment"),
     errMissing.text
   );
 
+  // The alias cannot declare per-action required fields, so it borrows the
+  // target's. This is the check that the borrowing works.
+  const errAliasMissing = await callTool("planka_manage_comment", {
+    action: "update",
+    commentId: "1",
+  });
+  check(
+    "ERROR: manage_comment update without text points at planka_update_comment",
+    errAliasMissing.isError &&
+      errAliasMissing.text.includes("text") &&
+      errAliasMissing.text.includes("planka_update_comment"),
+    errAliasMissing.text
+  );
+
   const errEmptyId = await callTool("planka_get_card", { cardId: "" });
   check(
     "ERROR: an empty id is rejected with an actionable message",
@@ -801,8 +1225,7 @@ async function run() {
     errNoop.text
   );
 
-  const errBadType = await callTool("planka_manage_lists", {
-    action: "create",
+  const errBadType = await callTool("planka_create_list", {
     boardId,
     name: `${PREFIX} should not exist`,
     position: "not-a-number",
@@ -856,9 +1279,25 @@ async function run() {
   );
 
   // --- teardown, verified ---------------------------------------------------
-  const deletedCard = await callTool("planka_delete_card", { cardId });
-  if (!deletedCard.isError) forget("cards", cardId);
-  check("planka_delete_card deletes the card", !deletedCard.isError, deletedCard.text);
+  // The copy and the bulk-move passenger are cards like any other: they have to
+  // be gone before the "no artifacts left" check below can mean anything.
+  for (const extraId of [duplicateId, strayCard?.card?.id].filter(Boolean)) {
+    const deletedExtra = await json("planka_delete_card", { cardId: extraId });
+    if (deletedExtra?.verified === true) forget("cards", extraId);
+    check(
+      `planka_delete_card removes the extra card ${extraId}, verified: true`,
+      deletedExtra?.verified === true,
+      deletedExtra
+    );
+  }
+
+  const deletedCard = await json("planka_delete_card", { cardId });
+  if (deletedCard?.verified === true) forget("cards", cardId);
+  check(
+    "planka_delete_card deletes the card, verified: true",
+    deletedCard?.verified === true,
+    deletedCard
+  );
 
   state = await rawBoard();
   check(
@@ -868,12 +1307,13 @@ async function run() {
   );
 
   for (const labelId of [labelA.label.id, labelB.label.id]) {
-    const deletedLabel = await callTool("planka_manage_labels", {
-      action: "delete",
-      labelId,
-    });
-    if (!deletedLabel.isError) forget("labels", labelId);
-    check(`planka_manage_labels delete (${labelId})`, !deletedLabel.isError, deletedLabel.text);
+    const deletedLabel = await json("planka_delete_label", { labelId });
+    if (deletedLabel?.verified === true) forget("labels", labelId);
+    check(
+      `planka_delete_label (${labelId}), verified: true`,
+      deletedLabel?.verified === true,
+      deletedLabel
+    );
   }
 
   state = await rawBoard();