@adrata/adrata-mcp 1.0.19 → 1.0.30

package/tools/source-control/connection-tools.js

@@ -1,5 +1,8 @@
 /** Read-only, product-visible health for Starfield's source-control ingestion. */
-export function registerSourceControlTools(server, { z, api, ok }) {
+export function registerSourceControlTools(
+  server,
+  { z, api, ok, validateApiBridgeRequest, buildMutationHeaders, getGrantedScope }
+) {
   server.tool(
     'list_source_control_connections',
     'List source-control connections with repository binding count, last durably acknowledged delivery, rejection state, actionable health, and the exact webhook events that are safe to enable.',
@@ -23,9 +26,122 @@ export function registerSourceControlTools(server, { z, api, ok }) {
       return ok({ events: response?.data ?? response ?? [] });
     }
   );
+
+  server.tool(
+    'bind_repository_to_board',
+    'Bind one repository to one board, so a merged pull request carrying a card id moves that card by itself.'
+      + ' Until a board is bound, every merge on it advances nothing and the column timestamps are hand-typed,'
+      + ' which is the input every cycle-time and control chart is built from.'
+      + ' Name BOTH mergeFromColumnId and mergeToColumnId or neither: one end alone is a half-configured rule'
+      + ' that silently does nothing, and the database CHECK constraint refuses it.'
+      + ' Governed write: previews by default. A live write requires dryRun:false plus approved:true, a reason,'
+      + ' and an idempotencyKey (reuse the SAME key on retry — a duplicate bind is refused as a 409).',
+    {
+      connectionId: z.string().describe('Source-control connection id, from list_source_control_connections.'),
+      boardId: z.string().describe('Board id from list_work_boards. One board binds once per connection.'),
+      externalRepoId: z.string().describe('The vendor’s own repository id, not its name.'),
+      externalFullName: z.string().describe('owner/name, e.g. adrata/adrata.'),
+      mergeFromColumnId: z
+        .string()
+        .optional()
+        .describe('Where a merged pull request’s card must be coming FROM. Both ends or neither.'),
+      mergeToColumnId: z
+        .string()
+        .optional()
+        .describe('Where it goes on merge. Both ends or neither.'),
+      onMergeAction: z
+        .enum(['advance', 'suggest', 'ignore'])
+        .optional()
+        .describe('Defaults to advance. `suggest` records the proposal without moving the card.'),
+      branchSample: z
+        .array(z.string())
+        .optional()
+        .describe(
+          'Recent branch names, newest first. NOT stored: the server measures how many already carry a card'
+            + ' reference and seeds the link strategies from what the repository actually does, rather than from'
+            + ' a form somebody filled in. Omitting it means the strategies are chosen without that evidence.'
+        ),
+      advanceOnlyWhenAllMerged: z
+        .boolean()
+        .optional()
+        .describe('Advance only when no linked change request is still open. Defaults true.'),
+      openPullsCardIntoProgress: z
+        .boolean()
+        .optional()
+        .describe('Does an OPENED pull request pull its card into In progress? Defaults false.'),
+      stagingEnvironmentName: z
+        .string()
+        .optional()
+        .describe('Exact vendor environment name. Absence means that evidence is not configured; never infer a role from a word like "staging".'),
+      productionEnvironmentName: z.string().optional().describe('Exact vendor environment name.'),
+      dryRun: z.boolean().optional().default(true),
+      approved: z.boolean().optional().default(false),
+      reason: z.string().optional(),
+      idempotencyKey: z.string().optional(),
+    },
+    async (args) => {
+      // Refused HERE rather than at the API, because the 400 this produces reads
+      // as a validation error about a column and the actual mistake is that only
+      // one end was named. `scm_repositories_move_shape_chk` enforces the same
+      // shape in the database; this says why before the round trip.
+      const from = args.mergeFromColumnId;
+      const to = args.mergeToColumnId;
+      if (Boolean(from) !== Boolean(to)) {
+        return ok({
+          error: true,
+          message:
+            'Name both mergeFromColumnId and mergeToColumnId, or neither. One end alone is a half-configured'
+            + ' move rule: it is accepted nowhere, and if it were, it would silently never fire — the failure'
+            + ' mode that takes longest to notice.',
+        });
+      }
+
+      const path = `/api/v1/scm/connections/${encodeURIComponent(args.connectionId)}/repositories`;
+      const body = {
+        boardId: args.boardId,
+        externalRepoId: args.externalRepoId,
+        externalFullName: args.externalFullName,
+        mergeFromColumnId: from,
+        mergeToColumnId: to,
+        onMergeAction: args.onMergeAction,
+        branchSample: args.branchSample,
+        advanceOnlyWhenAllMerged: args.advanceOnlyWhenAllMerged,
+        openPullsCardIntoProgress: args.openPullsCardIntoProgress,
+        stagingEnvironmentName: args.stagingEnvironmentName,
+        productionEnvironmentName: args.productionEnvironmentName,
+      };
+      const preview = validateApiBridgeRequest({
+        method: 'POST',
+        path,
+        body,
+        dryRun: args.dryRun,
+        approved: args.approved,
+        reason: args.reason,
+        idempotencyKey: args.idempotencyKey,
+        grantedScope: getGrantedScope(),
+      });
+      if (preview.dryRun) {
+        return ok({
+          dryRun: true,
+          action: `Bind ${args.externalFullName} to board ${args.boardId}`,
+          movesCardsOnMerge:
+            to === undefined
+              ? 'No. Without both column ends this binding records deliveries but advances nothing.'
+              : `Yes: a merged pull request moves its card ${from} -> ${to}.`,
+          note: 'Nothing was written. Confirm to create the binding.',
+        });
+      }
+      const data = await api('POST', path, {
+        body,
+        headers: buildMutationHeaders(args),
+      });
+      return ok({ bound: true, repository: data?.data ?? data });
+    }
+  );
 }
 
 export const SOURCE_CONTROL_TOOL_NAMES = [
   'list_source_control_connections',
   'get_source_control_connection_events',
+  'bind_repository_to_board',
 ];

package/tools/work-board-tools.js

@@ -274,7 +274,7 @@ export function registerWorkBoardTools(
   // public id and the handler adds the three private headers at the last hop.
   const workerLeaseCapabilities = new Map();
 
-  function rememberWorkerLease(itemId, grant, claimIdempotencyKey) {
+  function rememberWorkerLease(itemId, grant, claimIdempotencyKey, workerLabel) {
     if (!grant?.leaseId || !grant?.leaseToken || !Number.isInteger(grant?.fencingToken)) {
       throw new Error('The API returned an incomplete worker-lease grant; no capability was stored.');
     }
@@ -283,18 +283,32 @@ export function registerWorkBoardTools(
       leaseToken: grant.leaseToken,
       fencingToken: grant.fencingToken,
       claimIdempotencyKey,
+      workerLabel,
     });
     const { leaseToken: _secret, fencingToken: _fence, qaRequirements, currentCriteria, ...lease } =
       grant;
     return { lease, qaRequirements, currentCriteria };
   }
 
-  function conflictingHeldCard(itemId, claimIdempotencyKey) {
+  // ONE PASS PER WORKER, NOT PER PROCESS. A fleet runs many QA lanes through a
+  // single connector, so scanning every capability in the map made lane A's
+  // card refuse lane B — naming a card lane B had never seen and telling it to
+  // "transition or release" a peer's pass. That serialises the parallel QA
+  // drain the atomic claim exists to make safe, and it does so silently: the
+  // refusal reads exactly like ordinary contention for one card.
+  //
+  // The worker is what the guard was always about, and `workerLabel` is how a
+  // worker names itself. A capability stored without one cannot be attributed,
+  // so it still conflicts — an unattributable hold fails toward refusing, which
+  // costs a retry, rather than toward a double hold, which costs a lost lease.
+  function conflictingHeldCard(itemId, claimIdempotencyKey, workerLabel) {
     for (const [heldItemId, capability] of workerLeaseCapabilities) {
       const sameCard = itemId != null && heldItemId === itemId;
       const sameClaim =
         claimIdempotencyKey != null && capability.claimIdempotencyKey === claimIdempotencyKey;
-      if (!sameCard && !sameClaim) return heldItemId;
+      const sameWorker =
+        capability.workerLabel == null || capability.workerLabel === workerLabel;
+      if (!sameCard && !sameClaim && sameWorker) return heldItemId;
     }
     return null;
   }
@@ -511,7 +525,7 @@ Start here for "what should I work on". With includeUnassigned it also returns t
       idempotencyKey: z.string().optional(),
     },
     async (args) => {
-      const heldItemId = conflictingHeldCard(args.itemId, args.idempotencyKey);
+      const heldItemId = conflictingHeldCard(args.itemId, args.idempotencyKey, args.workerLabel);
       if (heldItemId) {
         return ok({
           error: true,
@@ -547,7 +561,7 @@ Start here for "what should I work on". With includeUnassigned it also returns t
         body,
         headers: buildMutationHeaders(args),
       });
-      const visible = rememberWorkerLease(args.itemId, data?.data, args.idempotencyKey);
+      const visible = rememberWorkerLease(args.itemId, data?.data, args.idempotencyKey, args.workerLabel);
       return ok({ claimed: true, ...visible });
     }
   );
@@ -567,7 +581,7 @@ Start here for "what should I work on". With includeUnassigned it also returns t
       idempotencyKey: z.string().optional(),
     },
     async (args) => {
-      const heldItemId = conflictingHeldCard(null, args.idempotencyKey);
+      const heldItemId = conflictingHeldCard(null, args.idempotencyKey, args.workerLabel);
       if (heldItemId) {
         return ok({
           error: true,
@@ -625,7 +639,12 @@ Start here for "what should I work on". With includeUnassigned it also returns t
             : `No eligible unclaimed ${args.product} ${args.qaGate} pass remains on any visible board.`,
         });
       }
-      const visible = rememberWorkerLease(selected.workItemId, selected.grant, args.idempotencyKey);
+      const visible = rememberWorkerLease(
+        selected.workItemId,
+        selected.grant,
+        args.idempotencyKey,
+        args.workerLabel
+      );
       return ok({
         claimed: true,
         skippedBlocked,
@@ -1484,11 +1503,25 @@ QA PASSES ARE THE EXCEPTION. An executable QA worker must hold the process-priva
       return ok({
         moved: true,
         claimed: args.claim === true,
-        // Echoed as a BOOLEAN, never as the receipt's contents. What the agent
-        // needs to know is whether the evidence was accepted; repeating a
+        // Read back from the SERVER, never `args.receipt !== undefined`. That
+        // echo reported the request rather than the answer, and the two
+        // disagree in all three directions: `receipt: {}` points at nothing and
+        // the server grades it `server_recorded`; offering no receipt at all
+        // still writes a `server_recorded` row, so `false` was wrong; and a
+        // REORDER writes no receipt whatsoever, because the API guards the
+        // write with `if changed_column` — yet a receipt passed alongside one
+        // still reported `true`.
+        //
+        // Still a BOOLEAN and still never the receipt's contents: repeating a
         // session pointer back into a conversation transcript is the leak this
         // whole field is shaped to avoid.
-        receiptRecorded: args.receipt !== undefined,
+        receiptRecorded: data?.receiptEvidenceSource != null,
+        // Whether that receipt points at anything, which is a different
+        // question from whether one exists — and it is the one the gaps query
+        // asks. `attested` only when the caller's references actually carried a
+        // value; `server_recorded` when the server wrote the row on its own
+        // observation; null when no receipt was written for this call.
+        receiptEvidenceSource: data?.receiptEvidenceSource ?? null,
         // Read back from the server rather than echoed from the request, because
         // the two halves of a claim are decided server-side and an agent that
         // assumed "claimed" meant "mine now" would report a QA pick-up as having
@@ -1605,7 +1638,12 @@ QA PASSES ARE THE EXCEPTION. An executable QA worker must hold the process-priva
       return ok({
         transferred: true,
         identityPreserved: true,
-        receiptRecorded: args.receipt !== undefined,
+        // The server's verdict, not an echo of the request. See the move tool
+        // above for why those differ. A transfer always changes board AND
+        // column, so unlike a move it always writes a receipt — but whether
+        // that receipt points at anything is still the server's call.
+        receiptRecorded: data?.receiptEvidenceSource != null,
+        receiptEvidenceSource: data?.receiptEvidenceSource ?? null,
         item: data?.data,
       });
     }
@@ -2570,7 +2608,11 @@ A FLAG IS NOT A TAG. The tag says how urgent the WORK is; a flag says the CARD i
 
 THE REASON IS REQUIRED IN BOTH DIRECTIONS, and it is not the audit reason — it is the text a human reads on the card. Raising says what is wrong; clearing says what resolved it. Anyone may clear a flag, which only works because both directions are recorded as a comment on the card.
 
-This is what the ship-the-card skill means by "an unworkable card is a triage problem, not a coding problem": flag it, say the one question that would unblock it, and stop.${GOVERNED_NOTE}`,
+This is what the ship-the-card skill means by "an unworkable card is a triage problem, not a coding problem": flag it, say the one question that would unblock it, and stop.
+
+A FLAG HANDS THE CARD ON; IT DOES NOT HIDE IT. Raising one leaves the card claimable, so another agent picks it up, reads your reason, and tries — and reflags with what it learned if it fails too. That loop is the point: write the reason for the next agent, not for a log. Say what you tried and what you ruled out, because they will otherwise re-derive it.
+
+PASS blocksClaim:true ONLY FOR A BLOCKER NO AGENT CAN SATISFY — an owner credential, a vendor consent, a product decision. That takes the card out of every reviewer's queue until somebody clears it by hand, so it is the wrong answer for "the test failed" or "I could not work out why". If another agent could plausibly get further, leave it claimable.${GOVERNED_NOTE}`,
     {
       itemId: z.string().describe('Card id.'),
       flagged: z
@@ -2583,6 +2625,12 @@ This is what the ship-the-card skill means by "an unworkable card is a triage pr
         .describe(
           'REQUIRED. Raising: what is wrong with the card. Clearing: what resolved it. Shown on the card and appended to its comment thread — write it for the person who will read it, not for a log.'
         ),
+      blocksClaim: z
+        .boolean()
+        .optional()
+        .describe(
+          'Whether this flag stops anyone picking the card up. OMITTED MEANS FALSE — the card stays claimable and another agent can try, which is what a flag is for. Pass true only for a blocker no agent can satisfy (an owner credential, a vendor consent, a decision); that hides the card until somebody clears the flag by hand. Ignored when clearing — clearing always restores the blocking default.'
+        ),
       dryRun: z.boolean().optional().describe('Defaults to true. Set false to change the flag.'),
       approved: z.boolean().optional().describe('Required true for a live change.'),
       idempotencyKey: z
@@ -2617,7 +2665,15 @@ This is what the ship-the-card skill means by "an unworkable card is a triage pr
       if (preview?.dryRun) {
         return ok({
           ...preview,
-          wouldFlag: { itemId: args.itemId, flagged: args.flagged, reason: args.reason },
+          wouldFlag: {
+            itemId: args.itemId,
+            flagged: args.flagged,
+            reason: args.reason,
+            // Shown in the rehearsal because it decides whether the card
+            // disappears from every queue, which is the consequence a reader
+            // most needs to see before approving the write.
+            blocksClaim: args.flagged ? (args.blocksClaim ?? false) : true,
+          },
         });
       }
 
@@ -2626,12 +2682,196 @@ This is what the ship-the-card skill means by "an unworkable card is a triage pr
           flagged: args.flagged,
           reason: args.reason,
           idempotencyKey: args.idempotencyKey,
+          // Sent only when the caller named it, so an older API that does not
+          // know the field is not handed one, and the server's own default
+          // (blocking) remains the single source of that decision.
+          ...(args.blocksClaim === undefined ? {} : { blocksClaim: args.blocksClaim }),
         },
         headers: buildMutationHeaders({ ...args, reason: args.reason }),
       });
       return ok({ flagged: args.flagged, item: data?.data });
     }
   );
+
+  // ── Retiring a card ──────────────────────────────────────────────────────
+  //
+  // Three tools rather than one with a `kind` switch, and the split is
+  // deliberate. `delete_` is matched by tool-annotations' DESTRUCTIVE_PATTERN,
+  // so naming the destructive branch as its own tool is what gets a host to
+  // confirmation-gate it. A single `archive_work_item({ kind: 'deleted' })`
+  // would hide the destructive path behind a name classified as safe.
+
+  const RETIRE_NOTE = `WHAT THIS IS NOT. Do not use move_work_item to Backlog or Deep backlog to retire a card. Those are PARKING: work still intended, later — it stays in every count, which is correct for parked work and wrong for work nobody will ever do. Retiring is the other thing, and it is the only one that takes the card out of the numbers.
+
+NOTHING IS DESTROYED. The card keeps its board, its column, its column history, its acceptance criteria and its QA evidence. It stays readable by get_work_item and it comes back with unarchive_work_item. The exclusion is a read filter, never a row removal — QA receipts bind to those column dwells and deleting them would leave every receipt on the card unexplainable.${GOVERNED_NOTE}`;
+
+  server.tool(
+    'archive_work_item',
+    `Retire a card: done with, wrong, obsolete, or superseded. It leaves every active count — the board's own size, the roll-up, the personal queue, velocity, capacity, the roadmap's card counts, the criterion standings — and stops being offered to a QA lane.
+
+This is the COMMON case and it is recoverable. Reach for it whenever a card should stop being counted; if you find yourself wanting to hide a card by moving it somewhere nobody looks, this is the tool you actually wanted.
+
+${RETIRE_NOTE}`,
+    {
+      itemId: z.string().describe('Card id.'),
+      reason: z
+        .string()
+        .describe(
+          'REQUIRED. Why this work will not be done. Shown on the card and appended to its comment thread — write it for the person who finds the card in six months and wonders what happened to it. "obsolete" is not an answer; "superseded by <card>, the API changed under it" is.'
+        ),
+      dryRun: z.boolean().optional().describe('Defaults to true. Set false to retire the card.'),
+      approved: z.boolean().optional().describe('Required true for a live change.'),
+      idempotencyKey: z
+        .string()
+        .optional()
+        .describe(
+          'Required for a live change. Reuse the SAME key on retry — retiring also appends a comment.'
+        ),
+    },
+    async (args) => {
+      if (!args.reason || !args.reason.trim()) {
+        return ok({
+          error: true,
+          message:
+            'reason is required. A card that disappears from the board with nothing written on it is exactly what archiving exists to replace.',
+        });
+      }
+      const path = `/api/v1/work-items/${encodeURIComponent(args.itemId)}/archive`;
+      const preview = validateApiBridgeRequest({
+        method: 'POST',
+        path,
+        dryRun: args.dryRun,
+        approved: args.approved,
+        reason: args.reason,
+        idempotencyKey: args.idempotencyKey,
+        grantedScope: getGrantedScope(),
+      });
+      if (preview?.dryRun) {
+        return ok({
+          ...preview,
+          wouldArchive: { itemId: args.itemId, kind: 'archived', reason: args.reason },
+        });
+      }
+      const data = await api('POST', path, {
+        body: { reason: args.reason, kind: 'archived', idempotencyKey: args.idempotencyKey },
+        headers: buildMutationHeaders({ ...args, reason: args.reason }),
+      });
+      return ok({ archived: true, kind: 'archived', item: data?.data });
+    }
+  );
+
+  server.tool(
+    'delete_work_item',
+    `Retire a card as DELETED rather than archived. Rare, and deliberate.
+
+PREFER archive_work_item. The two do the same thing to the numbers; the difference is what the record says about the decision, and "archived" is the honest word for almost every card. Use this only when the card should never have existed — a duplicate, a mis-filed capture, something created by an integration by mistake.
+
+IT IS STILL A SOFT DELETE. The row survives and unarchive_work_item brings it back. That is not a loophole: this board is the audit record behind a two-gate QA process, and a hard delete would cascade away the column history that every QA receipt binds to.
+
+YOU MUST ECHO THE CARD'S EXACT TITLE in confirmTitle. Read the card first with get_work_item; do not guess it from the id or from a list you are half sure of. The echo is the whole safeguard — it is what makes this something you cannot do by accident inside a loop.
+
+${RETIRE_NOTE}`,
+    {
+      itemId: z.string().describe('Card id.'),
+      confirmTitle: z
+        .string()
+        .describe(
+          "REQUIRED. The card's title, exactly as get_work_item returns it. A mismatch is refused and nothing is written."
+        ),
+      reason: z
+        .string()
+        .describe('REQUIRED. Why this card should never have existed.'),
+      dryRun: z.boolean().optional().describe('Defaults to true. Set false to delete the card.'),
+      approved: z.boolean().optional().describe('Required true for a live change.'),
+      idempotencyKey: z.string().optional().describe('Required for a live change.'),
+    },
+    async (args) => {
+      if (!args.reason || !args.reason.trim()) {
+        return ok({ error: true, message: 'reason is required to delete a card.' });
+      }
+      if (!args.confirmTitle || !args.confirmTitle.trim()) {
+        return ok({
+          error: true,
+          message:
+            "confirmTitle is required and must match the card's exact title. Read the card with get_work_item first — the echo is the only thing standing between a deliberate delete and an accidental one.",
+        });
+      }
+      const path = `/api/v1/work-items/${encodeURIComponent(args.itemId)}/archive`;
+      const preview = validateApiBridgeRequest({
+        method: 'POST',
+        path,
+        dryRun: args.dryRun,
+        approved: args.approved,
+        reason: args.reason,
+        idempotencyKey: args.idempotencyKey,
+        grantedScope: getGrantedScope(),
+      });
+      if (preview?.dryRun) {
+        return ok({
+          ...preview,
+          wouldDelete: {
+            itemId: args.itemId,
+            kind: 'deleted',
+            reason: args.reason,
+            confirmTitle: args.confirmTitle,
+          },
+        });
+      }
+      const data = await api('POST', path, {
+        body: {
+          reason: args.reason,
+          kind: 'deleted',
+          confirmTitle: args.confirmTitle,
+          idempotencyKey: args.idempotencyKey,
+        },
+        headers: buildMutationHeaders({ ...args, reason: args.reason }),
+      });
+      return ok({ archived: true, kind: 'deleted', item: data?.data });
+    }
+  );
+
+  server.tool(
+    'unarchive_work_item',
+    `Bring a retired card back into circulation, whichever verb retired it — archived or deleted. It rejoins every count exactly where it left, in the same column, with its whole history intact.
+
+As easy as retiring it was, on purpose: a retirement nobody could undo would make a mistaken one permanent, and that is the failure the confirmation on delete_work_item exists to prevent in the first place.
+
+THE REASON IS REQUIRED HERE TOO — what changed. Anyone can bring a card back, which only works if bringing it back leaves a record.${GOVERNED_NOTE}`,
+    {
+      itemId: z.string().describe('Card id. Find retired cards with the board archived-items read.'),
+      reason: z.string().describe('REQUIRED. What changed — why this work is wanted again.'),
+      dryRun: z.boolean().optional().describe('Defaults to true. Set false to restore the card.'),
+      approved: z.boolean().optional().describe('Required true for a live change.'),
+      idempotencyKey: z.string().optional().describe('Required for a live change.'),
+    },
+    async (args) => {
+      if (!args.reason || !args.reason.trim()) {
+        return ok({
+          error: true,
+          message:
+            'reason is required to restore a card. Anyone can bring a card back, which only works if bringing it back leaves a record.',
+        });
+      }
+      const path = `/api/v1/work-items/${encodeURIComponent(args.itemId)}/unarchive`;
+      const preview = validateApiBridgeRequest({
+        method: 'POST',
+        path,
+        dryRun: args.dryRun,
+        approved: args.approved,
+        reason: args.reason,
+        idempotencyKey: args.idempotencyKey,
+        grantedScope: getGrantedScope(),
+      });
+      if (preview?.dryRun) {
+        return ok({ ...preview, wouldUnarchive: { itemId: args.itemId, reason: args.reason } });
+      }
+      const data = await api('POST', path, {
+        body: { reason: args.reason, idempotencyKey: args.idempotencyKey },
+        headers: buildMutationHeaders({ ...args, reason: args.reason }),
+      });
+      return ok({ archived: false, item: data?.data });
+    }
+  );
 }
 
 /** Tool names registered here, for the tier map and the toolset manifest. */
@@ -2674,6 +2914,9 @@ export const WORK_BOARD_TOOL_NAMES = [
   'get_work_item_comments',
   'comment_on_work_item',
   'flag_work_item',
+  'archive_work_item',
+  'delete_work_item',
+  'unarchive_work_item',
   'block_work_item',
   'unblock_work_item',
 ];

package/tools/work-hub/criteria-quality.js

@@ -110,8 +110,10 @@ const UNLOCATED_WHERE = [
 ];
 
 /** Text nobody has written yet, left in a field that is required to be written. */
+// WIP limit(s) names the board feature, not unfinished prose. Exempt only that
+// noun phrase; bare WIP and separate placeholders in the same field still fire.
 const PLACEHOLDER =
-  /(?:^|[^a-z0-9])(?:tbd|tba|todo|fixme|wip|xxx|placeholder|n\/a)(?:[^a-z0-9]|$)|\?{3,}|<[^>]{0,40}>/i;
+  /(?:^|[^a-z0-9])(?:tbd|tba|todo|fixme|wip(?![\s-]+limits?\b)|xxx|placeholder|n\/a)(?:[^a-z0-9]|$)|\?{3,}|<[^>]{0,40}>/i;
 
 const PART_LABELS = {
   whereText: 'where',