@taiga-ai/mcp-server 0.36.0-rc.933 → 0.37.0-dev.940

package/README.md

@@ -14,7 +14,7 @@ You need an access key, made in Taiga under **Settings > Account > MCP**, where
 
 Create the key first, and choose when it expires: in 30 days, 90 days, a year, or never. Taiga copies it to your clipboard, shows it once, and keeps it on the page until you say you have saved it, so copying the setup next does not lose it.
 
-The same page shows the setup for your client and environment, with the key already filled in where a config file needs it, and a one-click install for Cursor. The examples here pin a release (`@taiga-ai/mcp-server@0.36.0`), so an install runs the version you chose rather than whatever `latest` is at the next start.
+The same page shows the setup for your client and environment, with the key already filled in where a config file needs it, and a one-click install for Cursor. The examples here pin a release (`@taiga-ai/mcp-server@0.37.0`), so an install runs the version you chose rather than whatever `latest` is at the next start.
 
 ## Install
 
@@ -23,21 +23,21 @@ The same page shows the setup for your client and environment, with the key alre
 Run the command. When it asks for your access key, paste it once and press Enter. Nothing appears as you paste (PowerShell shows asterisks), and the key stays out of your shell history:
 
 ```sh
-printf 'Taiga access key: ' && read -rs TAIGA_API_KEY && echo && claude mcp add taiga --scope user -e TAIGA_API_KEY="$TAIGA_API_KEY" -- npx -y @taiga-ai/mcp-server@0.36.0
+printf 'Taiga access key: ' && read -rs TAIGA_API_KEY && echo && claude mcp add taiga --scope user -e TAIGA_API_KEY="$TAIGA_API_KEY" -- npx -y @taiga-ai/mcp-server@0.37.0
 ```
 
 ```sh
-printf 'Taiga access key: ' && read -rs TAIGA_API_KEY && echo && codex mcp add taiga --env TAIGA_API_KEY="$TAIGA_API_KEY" -- npx -y @taiga-ai/mcp-server@0.36.0
+printf 'Taiga access key: ' && read -rs TAIGA_API_KEY && echo && codex mcp add taiga --env TAIGA_API_KEY="$TAIGA_API_KEY" -- npx -y @taiga-ai/mcp-server@0.37.0
 ```
 
 On Windows, in PowerShell (Claude Code needs `cmd /c` to start `npx`; the quoted `'--'` survives npm's PowerShell shims):
 
 ```powershell
-$k = Read-Host 'Taiga access key' -AsSecureString; claude mcp add taiga --scope user -e "TAIGA_API_KEY=$([Net.NetworkCredential]::new('', $k).Password)" '--' cmd /c npx -y @taiga-ai/mcp-server@0.36.0
+$k = Read-Host 'Taiga access key' -AsSecureString; claude mcp add taiga --scope user -e "TAIGA_API_KEY=$([Net.NetworkCredential]::new('', $k).Password)" '--' cmd /c npx -y @taiga-ai/mcp-server@0.37.0
 ```
 
 ```powershell
-$k = Read-Host 'Taiga access key' -AsSecureString; codex mcp add taiga --env "TAIGA_API_KEY=$([Net.NetworkCredential]::new('', $k).Password)" '--' npx -y @taiga-ai/mcp-server@0.36.0
+$k = Read-Host 'Taiga access key' -AsSecureString; codex mcp add taiga --env "TAIGA_API_KEY=$([Net.NetworkCredential]::new('', $k).Password)" '--' npx -y @taiga-ai/mcp-server@0.37.0
 ```
 
 ### Cursor, Windsurf, Claude Desktop and other MCP clients
@@ -49,7 +49,7 @@ Most clients read the same `mcpServers` block. Add it with your key in place of
   "mcpServers": {
     "taiga": {
       "command": "npx",
-      "args": ["-y", "@taiga-ai/mcp-server@0.36.0"],
+      "args": ["-y", "@taiga-ai/mcp-server@0.37.0"],
       "env": { "TAIGA_API_KEY": "YOUR_ACCESS_KEY" }
     }
   }
@@ -78,7 +78,7 @@ In `.vscode/mcp.json`. VS Code reads `servers`, and prompts for the key once and
     "taiga": {
       "type": "stdio",
       "command": "npx",
-      "args": ["-y", "@taiga-ai/mcp-server@0.36.0"],
+      "args": ["-y", "@taiga-ai/mcp-server@0.37.0"],
       "env": { "TAIGA_API_KEY": "${input:taiga-api-key}" }
     }
   }

package/dist/index.js

@@ -23969,22 +23969,20 @@ var TaigaClient = class {
 	async remediatePolicyViolation(productId, divergenceId, body = {}) {
 		return this.request("POST", `/products/${seg(productId)}/maintenance/policies/divergences/${seg(divergenceId)}/remediate`, body);
 	}
-	async listInbox(opts) {
-		const { productId, ...rest } = opts;
-		const path = productId ? `/products/${seg(productId)}/inbox` : "/inbox";
-		return this.request("GET", `${path}${query$1({ ...rest })}`);
-	}
 	/**
-	* The requests waiting on the caller (GET /users/me/requests), the read the
-	* web's Action required page merges with the inbox: a licence nobody
-	* approved (license_review, PRO-3313) is one, listed only for a caller who
-	* can change the list.
+	* What waits on a person (GET /users/me/requests), up to the API's cap, with
+	* what is assigned to someone else: a key speaks for the team's work.
 	*/
-	async listMyRequests() {
-		return this.request("GET", "/users/me/requests");
+	async listRequests() {
+		return this.request("GET", `/users/me/requests${query$1({ everyone: "true" })}`);
+	}
+	/** What closed in the last two weeks (GET /users/me/requests/done), by the same rules. */
+	async listDoneRequests() {
+		return this.request("GET", `/users/me/requests/done${query$1({ everyone: "true" })}`);
 	}
-	async updateInboxItem(id, body) {
-		return this.request("PATCH", `/inbox/${seg(id)}`, body);
+	/** Answer a request with one of the answers it offers. */
+	async answerRequest(id, exit) {
+		return this.request("POST", `/requests/${seg(id)}/answer`, { exit });
 	}
 	async listSetupTasks(opts) {
 		const { productId, ...rest } = opts;
@@ -25370,23 +25368,6 @@ function hardeningCoverage(result) {
 }
 //#endregion
 //#region ../../packages/types/dist/inbox.js
-/** What action is required. Drives icon, copy, and completion logic. */
-const INBOX_ITEM_KINDS = [
-	"review_plan",
-	"review_backlog",
-	"review_doc",
-	"review_pr",
-	"review_maintenance",
-	"review_policy",
-	"attest_policy",
-	"setup_env_var",
-	"setup_secret",
-	"setup_third_party",
-	"setup_dns",
-	"setup_billing",
-	"setup_cloud_permission",
-	"setup_manual"
-];
 /** The kind of manual setup the agents identified. */
 const INBOX_TASK_CATEGORIES = [
 	"env_var",
@@ -26236,11 +26217,72 @@ Object.freeze({
 	gracePeriodDays: 0,
 	requiredSince: null
 });
+//#endregion
+//#region ../../packages/types/dist/notifications.js
+/**
+* What the contact is FOR, in the AWS alternate-contacts sense.
+*
+* Only `default` is populated today. The column exists from day one anyway,
+* because retrofitting a type onto rows already in the wild means guessing what
+* each one was for. `security`, `operations` and `billing` become meaningful
+* once there are event classes to route to them.
+*/
+const NOTIFICATION_CONTACT_TYPES = [
+	"default",
+	"security",
+	"operations",
+	"billing"
+];
 [...TURN_EVENT_TRIGGERS];
 /** Longest request for changes from Taiga (PRO-3035): about four pages of prose. */
 const CHANGE_REQUEST_MAX_CHARS = 1e4;
 //#endregion
 //#region ../../packages/types/dist/requests.js
+/**
+* What a request asks for. Mirrored by a database CHECK on `requests.kind`.
+*
+*  - `stop`         the line stopped on an initiative and waits on a person
+*                   to choose a way on (PRO-2616): the needs-human flag, as a
+*                   request.
+*  - `plan_review`  a plan landed with the build gate closed and waits on a
+*                   person's verdict before anything is built (PRO-2617).
+*  - `pr_review`    a build's pull request waits on a person to review and
+*                   merge it, auto-merge not owning it (PRO-2655).
+*  - `setup`        a manual setup task an agent identified (a variable, a
+*                   secret, a DNS record...) waits on a person (PRO-2700).
+*                   Advisory: nothing waits on it.
+*  - `document_review`  a published document version waits on a person's
+*                   sign-off (PRO-2701). Advisory: nothing waits on it.
+*  - `maintenance_review`  a product's maintenance findings wait on a
+*                   person's review (PRO-2702): one per product, raised when
+*                   a sweep brings news. Advisory: nothing waits on it.
+*  - `policy_review`  a product's policy divergences wait on a person's
+*                   review (PRO-2702): one per product, raised when an
+*                   assessment after a refresh finds new ones. Advisory.
+*  - `document_check`  something the document pipeline found in one of a
+*                   product's documents waited on a person (PRO-2703): a
+*                   reference or fact it could not fix, or a product decision
+*                   only a person can make. One per check, under its key
+*                   (`<documentType>:doc-lint`, `:facts`,
+*                   `:decision:<hash>`), on the product. Retired: no longer
+*                   raised, and none is open -- a document asks for a review
+*                   and nothing else. Its closed rows remain.
+*  - `license_review`  a licence nobody approved is in use in a product
+*                   (PRO-3313): one per product and licence, under the
+*                   licence's SPDX id as its key, for whoever can change the
+*                   organization's approved list. Advisory.
+*/
+const REQUEST_KINDS = [
+	"stop",
+	"plan_review",
+	"pr_review",
+	"setup",
+	"document_review",
+	"maintenance_review",
+	"policy_review",
+	"document_check",
+	"license_review"
+];
 /** Every way a request can be answered, whatever its kind. */
 const REQUEST_EXITS = [
 	"resume_run",
@@ -27194,6 +27236,14 @@ function isSharedHostingDomain(host) {
 	return SHARED_HOSTING_DOMAINS.includes(host);
 }
 strictObject({});
+strictObject({
+	address: string$2().trim().toLowerCase().email("Enter a valid email address").max(320),
+	contactType: _enum(NOTIFICATION_CONTACT_TYPES).optional()
+});
+object({
+	verificationSent: boolean(),
+	verificationError: string$2().nullable()
+});
 const uuid = string$2().uuid();
 const sha256 = string$2().regex(/^[0-9a-f]{64}$/, "sha256 must be 64 lowercase hex characters");
 object({ jobId: string$2() });
@@ -27839,7 +27889,7 @@ Object.freeze({
 * reads as deleted) and fields they explain would simply be missing. So it
 * refuses to start, and says what to do.
 */
-function apiLevelProblem(introspection, apiUrl, required = 8, version = SERVER_VERSION) {
+function apiLevelProblem(introspection, apiUrl, required = 9, version = SERVER_VERSION) {
 	const offered = introspection.mcpApiLevel ?? 0;
 	if (offered >= required) return null;
 	return `The Taiga API at ${apiUrl} is older than @taiga-ai/mcp-server ${version} needs (API level ${offered}, needs ${required}). Run the version published for it, or wait for that API to be updated; an earlier release of this package works against it.`;
@@ -28406,7 +28456,7 @@ function inProductWords(value) {
 }
 /** The API's 404 sentence in the product's words: "Backlog item not found" is an initiative not found. */
 function inProductWording(said) {
-	return said.replace(/^Backlog item not found/i, "Initiative not found").replace(/^Build run step not found/i, "Run step not found").replace(/^Build run not found/i, "Run not found").replace(/^Custom document not found/i, "Knowledge file not found").replace(/^(Branch "[^"]*" does not exist in \S+?)\.?$/i, "$1. taiga_list_repository_branches lists the branches it has.").replace(/^This product already has a repository\. Change it instead of linking another\./i, "This product already has a repository. Pass replacesLinkId to swap it in one step, or taiga_unlink_repository first (taiga_list_product_repositories gives its ID).");
+	return said.replace(/^Backlog item not found/i, "Initiative not found").replace(/^Build run step not found/i, "Run step not found").replace(/^Build run not found/i, "Run not found").replace(/^Custom document not found/i, "Knowledge file not found").replace(/^(Branch "[^"]*" does not exist in \S+?)\.?$/i, "$1. taiga_list_repository_branches lists the branches it has.");
 }
 /**
 * A float without its binary noise: six significant digits. Delivery metrics
@@ -36733,7 +36783,7 @@ const PLANNER_REASON_MAX = 600;
 /** Words a sentence does not end at: "e.g." and the like, and a lone initial. */
 const ABBREVIATION = /(?:\b(?:e\.g|i\.e|etc|vs|cf|incl|approx)|(?:^|\s)[A-Za-z])\.$/i;
 /** A finding's first sentence, capped: it ends at . ! or ? before white space, but not at an abbreviation. */
-function firstSentence$1(text) {
+function firstSentence(text) {
 	let sentence = text;
 	for (const match of text.matchAll(/[.!?](?=\s|$)/g)) {
 		const end = match.index + 1;
@@ -36751,7 +36801,7 @@ function hardeningSaid(blocking, named) {
 	const count = `Hardening ended with ${blocking} blocking finding${blocking === 1 ? "" : "s"} it could not fix`;
 	if (named.length === 0) return `${count}; this run predates recording which.`;
 	const shown = named.slice(0, 3).map((finding) => {
-		const message = firstSentence$1(String(finding["message"]));
+		const message = firstSentence(String(finding["message"]));
 		const where = finding["line"] ? `${String(finding["path"])}:${String(finding["line"])}` : String(finding["path"]);
 		return `${message} (${String(finding["tool"])}, ${where})`;
 	});
@@ -38630,294 +38680,122 @@ function registerDesignTokenTools(server, client, wait) {
 }
 //#endregion
 //#region src/tools/inbox.ts
-/**
-* An item as a row: what it is, whose product, how long it has waited. Not
-* its metadata by default: a document decision carried its whole text there,
-* and fifty rows came to 57 KB (PRO-2800); full: true brings it.
-*/
-const ITEM_FIELDS = [
-	"id",
-	"productId",
-	"productName",
-	"category",
-	"kind",
-	"subjectType",
-	"subjectId",
-	"title",
-	"summary",
-	"status",
-	"blocking",
-	"snoozedUntil",
-	"createdAt",
-	"resolvedAt"
-];
 const DAY_MS = 864e5;
-/** When an item stopped waiting: its resolution, or now while it is open. */
-function waitedUntil(resolvedAt, now) {
-	const at = typeof resolvedAt === "string" ? Date.parse(resolvedAt) : NaN;
-	return Number.isNaN(at) ? now : at;
-}
-/**
-* The read that opens an item's subject (PRO-2800): rows carried subjectType and subjectId, and the reviewing agent
-* had to infer which tool takes them.
-*/
+/** The kinds a row can be: a document check is retired, and listed no more. */
+const LISTED_KINDS = REQUEST_KINDS.filter((kind) => kind !== "document_check");
+/** The read that opens a request's subject (PRO-2800): what is on an initiative needs backlog:read. */
 function readWith(row, backlogRead) {
-	switch (row["subjectType"]) {
-		case "build_run": return backlogRead ? "taiga_get_run (runId: subjectId)" : void 0;
-		case "backlog_item": return backlogRead ? "taiga_get_plan (initiativeId: subjectId)" : void 0;
-		case "product_document": {
-			const type = /^[^:]+:([a-z_]+):decision:/.exec(String(row["subjectId"]))?.[1];
-			return type ? `taiga_get_product_document (productId, type: ${type}); the decision's text is this row with full: true` : "taiga_get_product_document (productId, no type)";
-		}
-		case "inbox_task": return "taiga_list_setup_tasks (productId)";
-		case "product": return {
-			review_backlog: backlogRead ? "taiga_list_initiatives (productId)" : void 0,
-			review_maintenance: "taiga_list_findings (productId)",
-			review_policy: "taiga_get_policy_standing (productId)",
-			review_doc: "taiga_get_product_document (productId, no type)"
-		}[String(row["kind"])];
+	const product = row["product"] ?? {};
+	const productRead = `productId: ${String(product["id"])}`;
+	switch (row["kind"]) {
+		case "stop": return backlogRead ? `taiga_get_initiative (initiativeId: ${String(subjectIdOf(row))})` : void 0;
+		case "plan_review": return backlogRead ? `taiga_get_plan (initiativeId: ${String(subjectIdOf(row))})` : void 0;
+		case "pr_review": return backlogRead ? `taiga_get_run (runId: ${String(dataOf(row)["buildRunId"])})` : void 0;
+		case "setup": return `taiga_list_setup_tasks (${productRead})`;
+		case "document_review": return `taiga_get_product_document (${productRead}, type: ${String(dataOf(row)["documentType"])})`;
+		case "maintenance_review": return `taiga_list_findings (${productRead})`;
+		case "policy_review": return `taiga_get_policy_standing (${productRead})`;
 		default: return;
 	}
 }
-/**
-* The glossary's words for what the API names after its tables (PRO-2823): a reviewer met kind review_backlog,
-* subjectType backlog_item and inbox_task beside a glossary that says initiative and run, and had to infer they
-* were the same things.
-*/
-const KIND_SAID = { review_backlog: "review_initiatives" };
-/** The kinds as the rows say them, for the kind filter, and the way back to the API's word. */
-const KINDS_SAID = INBOX_ITEM_KINDS.map((kind) => KIND_SAID[kind] ?? kind);
-const KIND_FROM_SAID = Object.fromEntries(Object.entries(KIND_SAID).map(([api, said]) => [said, api]));
-const SUBJECT_SAID = {
-	backlog_item: "initiative",
-	build_run: "run",
-	inbox_task: "setup_task"
-};
-const kindSaid = (kind) => KIND_SAID[String(kind)] ?? kind;
-/** A setup task row in the glossary's words: the Action Required item it is, by the name taiga_resolve_action takes. */
-function setupTaskRow(row) {
-	const { inboxItemId, inboxItemStatus, alsoFiledAs, ...rest } = row;
-	return {
-		...rest,
-		...inboxItemId !== void 0 ? { actionId: inboxItemId } : {},
-		...inboxItemStatus !== void 0 ? { actionStatus: inboxItemStatus } : {},
-		...Array.isArray(alsoFiledAs) ? { alsoFiledAs: alsoFiledAs.map(setupTaskRow) } : {}
-	};
-}
-/**
-* The licences nobody approved, in use in a product (PRO-3313, PRO-3396): requests rather than inbox items, so
-* the inbox read never listed them, though the web's Action required page does. Read for a key that can change
-* the list (the API lists them to nobody else), on the first page, and best effort: a failed read leaves them
-* out, not the page.
-*/
-async function licenseReviews(client, productId, now) {
-	if (!client.hasCapability("tenant:settings")) return null;
-	try {
-		const result = await client.listMyRequests();
-		return {
-			rows: result.data.filter((r) => r["kind"] === "license_review").map((r) => {
-				const product = r["product"] ?? {};
-				const data = r["data"] ?? {};
-				const created = typeof r["createdAt"] === "string" ? Date.parse(r["createdAt"]) : NaN;
-				return {
-					id: r["id"],
-					productId: product["id"],
-					productName: product["name"],
-					kind: "review_license",
-					license: data["license"],
-					packages: data["packages"],
-					...Number.isNaN(created) ? {} : { waitingDays: Math.floor((now - created) / DAY_MS) },
-					readWith: "taiga_list_licenses (license)",
-					decideWith: "taiga_change_license (license, action: 'approve') for every product" + (client.hasCapability("products:write") ? ", or taiga_allow_license (productId, license) for this one" : "") + "; dismissing it is only in the web"
-				};
-			}).filter((r) => productId === void 0 || r.productId === productId),
-			truncated: result.truncated === true
-		};
-	} catch (err) {
-		if (err instanceof TaigaApiError || isNetworkFailure(err)) return null;
-		throw err;
-	}
-}
-/** A summary past its first sentence: review_doc rows quoted two documents, 800 to 1,200 characters each. */
-const SUMMARY_LIMIT = 200;
-function firstSentence(text) {
-	if (typeof text !== "string") return text;
-	const head = text.split(/\n/)[0].trim();
-	if (head.length <= SUMMARY_LIMIT) return head.length < text.trim().length ? `${head} (full: true has the rest)` : head;
-	const cut = head.slice(0, SUMMARY_LIMIT);
-	const end = Math.max(cut.lastIndexOf(". "), cut.lastIndexOf("; "));
-	return `${end > 40 ? cut.slice(0, end + 1) : cut}... (full: true has the rest)`;
-}
-/** A row as an agent reads it: the pull request to open when there is one, and how many days it has waited. */
-function itemRow(row, now, full, backlogRead) {
-	const { snoozedUntil, resolvedAt, ...rest } = pickFields([row], ITEM_FIELDS)[0];
-	const metadata = row["metadata"] ?? {};
+const dataOf = (row) => row["data"] ?? {};
+const subjectIdOf = (row) => (row["subject"] ?? {})["id"];
+/** What a request asks, in a line: a request holds no title of its own. */
+function titleOf(row) {
+	const data = dataOf(row);
+	const initiative = row["initiative"] ?? {};
+	const named = typeof initiative["title"] === "string" ? initiative["title"] : "an initiative";
+	switch (row["kind"]) {
+		case "stop": return `Stopped: ${named}`;
+		case "plan_review": return `Review plan: ${named}`;
+		case "pr_review": return `Review pull request #${String(data["prNumber"])}: ${named}`;
+		case "setup": return String(data["title"]);
+		case "document_review": return `Review ${String(data["documentType"])}, version ${String(data["version"])}`;
+		case "maintenance_review": return `Review ${String(data["openFindings"])} findings`;
+		case "policy_review": return `Review ${String(data["openDivergences"])} policy violations`;
+		case "license_review": return `Review license ${String(data["license"])}`;
+		default: return String(row["kind"]);
+	}
+}
+/** A request as an agent reads it: what it asks, how long it has waited, and which read opens it. */
+function requestRow(row, now, backlogRead, full) {
+	const product = row["product"] ?? {};
+	const pullRequest = row["pullRequest"];
+	const closed = row["closed"];
 	const created = typeof row["createdAt"] === "string" ? Date.parse(row["createdAt"]) : NaN;
-	const { summary, status, blocking, ...lean } = rest;
+	const until = typeof closed?.["closedAt"] === "string" ? Date.parse(closed["closedAt"]) : now;
 	const read = readWith(row, backlogRead);
-	const saysNothing = row["kind"] === "setup_manual" && String(summary).trim().toLowerCase() === "manual config";
 	return {
-		...lean,
-		kind: kindSaid(lean["kind"]),
-		...typeof lean["subjectType"] === "string" ? { subjectType: SUBJECT_SAID[lean["subjectType"]] ?? lean["subjectType"] } : {},
-		...saysNothing ? {} : full ? { summary } : row["kind"] === "review_pr" ? {} : { summary: firstSentence(summary) },
-		...full || status !== "open" ? { status } : {},
-		...full || blocking === true ? { blocking } : {},
+		id: row["id"],
+		productId: product["id"],
+		productName: product["name"],
+		kind: row["kind"],
+		title: titleOf(row),
+		...row["blocking"] === true ? { blocking: true } : {},
+		...row["kind"] === "stop" ? {
+			cause: dataOf(row)["cause"],
+			detail: dataOf(row)["detail"]
+		} : {},
 		...read ? { readWith: read } : {},
-		...snoozedUntil ? { snoozedUntil } : {},
-		...resolvedAt ? { resolvedAt } : {},
-		...typeof metadata["prUrl"] === "string" ? { prUrl: metadata["prUrl"] } : {},
-		...Number.isNaN(created) ? {} : { waitingDays: Math.floor((waitedUntil(resolvedAt, now) - created) / DAY_MS) },
-		...full ? { metadata: row["metadata"] } : {}
+		...typeof pullRequest?.["url"] === "string" ? { prUrl: pullRequest["url"] } : {},
+		...closed ? { closed } : {},
+		...Number.isNaN(created) ? {} : { waitingDays: Math.floor((until - created) / DAY_MS) },
+		...full ? {
+			data: row["data"],
+			answers: row["exits"]
+		} : {}
 	};
 }
-/**
-* What is open, counted by product and kind: the answer to "what needs attention" without reading every row. An item
-* that no longer stands is counted under stale, not open or byKind, so nobody subtracts by hand (PRO-2800).
-*/
-function summaryOf(rows, stale) {
+/** The licence reviews, read apart: what decides one is another tool's, for every product or one. */
+function licenseRow(client, row, now) {
+	const product = row["product"] ?? {};
+	const data = dataOf(row);
+	const created = typeof row["createdAt"] === "string" ? Date.parse(row["createdAt"]) : NaN;
+	return {
+		id: row["id"],
+		productId: product["id"],
+		productName: product["name"],
+		kind: "license_review",
+		license: data["license"],
+		packages: data["packages"],
+		...Number.isNaN(created) ? {} : { waitingDays: Math.floor((now - created) / DAY_MS) },
+		readWith: "taiga_list_licenses (license)",
+		decideWith: "taiga_change_license (license, action: 'approve') for every product" + (client.hasCapability("products:write") ? ", taiga_allow_license (productId, license, allowed: true) for this one, or taiga_resolve_action (actionId: id, answer: 'dismiss')" : "")
+	};
+}
+/** What is open, counted by product and kind: the answer to "what needs attention" without reading every row. */
+function summaryOf(rows) {
 	const byProduct = /* @__PURE__ */ new Map();
 	for (const row of rows) {
-		const key = String(row["productId"]);
-		const entry = byProduct.get(key) ?? (row["productName"] ? {
-			productId: key,
-			product: row["productName"],
-			open: 0,
-			byKind: {}
-		} : {
+		const product = row["product"] ?? {};
+		const key = String(product["id"]);
+		const entry = byProduct.get(key) ?? {
 			productId: key,
+			product: product["name"],
 			open: 0,
 			byKind: {}
-		});
-		if (stale.has(String(row["id"]))) entry.stale = (entry.stale ?? 0) + 1;
-		else {
-			entry.open += 1;
-			const kind = String(kindSaid(row["kind"]));
-			entry.byKind[kind] = (entry.byKind[kind] ?? 0) + 1;
-		}
+		};
+		entry.open += 1;
+		const kind = String(row["kind"]);
+		entry.byKind[kind] = (entry.byKind[kind] ?? 0) + 1;
 		byProduct.set(key, entry);
 	}
 	return [...byProduct.values()].sort((a, b) => b.open - a.open);
 }
-/** Pull request reviews checked against their run and initiative; past this a row is left as it is. */
-const STALE_CHECKS = 10;
-/**
-* Which "Review & merge" items no longer stand, and why (PRO-2800): the run's
-* pull request closed or merged, or its initiative was canceled or finished
-* without it. Two reviewing agents counted such leftovers as live gates; the
-* row still is open in Action Required, so this says what it is now rather
-* than hiding it. Best effort, a handful of runs: a failed read leaves the
-* row as it was.
-*/
-async function staleReviews(client, rows) {
-	const byId = new Map(rows.filter((row) => row["kind"] === "review_pr" && row["subjectType"] === "build_run").map((row) => [String(row["id"]), row]));
-	const candidates = [...byId.values()].slice(0, STALE_CHECKS);
-	const uncheckedIds = new Set([...byId.keys()].slice(STALE_CHECKS));
-	const out = /* @__PURE__ */ new Map();
-	await Promise.all(candidates.map(async (row) => {
-		if (!client.hasCapability("backlog:read")) return void uncheckedIds.add(String(row["id"]));
-		try {
-			const run = (await client.getBuildRun(String(row["subjectId"]))).data;
-			if (run["prMerged"] === true) return void out.set(String(row["id"]), "its pull request has merged");
-			if (run["prState"] === "closed") return void out.set(String(row["id"]), "its pull request was closed");
-			if (typeof run["backlogItemId"] !== "string") return;
-			const item = (await client.getBacklogItem(run["backlogItemId"])).data;
-			if (item["state"] === "canceled" || item["status"] === "canceled") out.set(String(row["id"]), "its initiative was canceled; the pull request is still open on the forge");
-			else if (item["state"] === "done" || item["status"] === "done") out.set(String(row["id"]), "its initiative is done; this run is not the one that landed it");
-		} catch (error) {
-			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
-			uncheckedIds.add(String(row["id"]));
-		}
-	}));
-	await staleBacklogReviews(client, rows, out, uncheckedIds);
-	return {
-		stale: out,
-		unchecked: uncheckedIds.size,
-		uncheckedIds
-	};
-}
-/**
-* "Review Initiatives" items whose product has no initiative left in its backlog or todo column (PRO-2800): two reviews found one
-* waiting 15 days on a product whose initiatives had all moved on, with nothing an agent could act on. Best effort,
-* a handful of products; returns how many could not be checked.
-*/
-async function staleBacklogReviews(client, rows, out, unchecked) {
-	const asks = [...new Map(rows.filter((row) => row["kind"] === "review_backlog" && typeof row["productId"] === "string").map((row) => [String(row["id"]), row])).values()];
-	const skip = (which) => which.forEach((row) => unchecked.add(String(row["id"])));
-	if (asks.length === 0) return;
-	if (!client.hasCapability("backlog:read")) return skip(asks);
-	const checked = [...new Set(asks.map((row) => String(row["productId"])))].slice(0, STALE_CHECKS);
-	skip(asks.filter((row) => !checked.includes(String(row["productId"]))));
-	const empty = /* @__PURE__ */ new Set();
-	await Promise.all(checked.map(async (productId) => {
-		try {
-			if ((await Promise.all(["backlog", "todo"].map((state) => client.listBacklogItems(productId, {
-				state,
-				limit: 1
-			})))).some((page) => page.data.length > 0)) return;
-			empty.add(productId);
-		} catch (error) {
-			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
-			skip(asks.filter((row) => row["productId"] === productId));
-		}
-	}));
-	for (const row of asks) if (empty.has(String(row["productId"]))) out.set(String(row["id"]), "no initiative is in the backlog or todo now: the ones it asked about have moved on");
-}
-/**
-* One product's Action Required as counts, the way the list's summary counts them: open is what still stands and is
-* not put off, stale and snoozed are counted apart. The product context reports these, so the two reads agree.
-*/
-async function attentionCounts(client, rows) {
-	const now = Date.now();
-	const due = rows.filter((row) => isDue(row, now));
-	const { stale, unchecked } = await staleReviews(client, due);
-	const [entry] = summaryOf(due, stale);
-	const snoozed = rows.length - due.length;
+/** The request's product, when the tool asks about one. */
+const inProduct = (productIdWanted) => (row) => productIdWanted === void 0 || (row["product"] ?? {})["id"] === productIdWanted;
+/** One product's Action Required as counts, as the list's summary counts them. */
+async function attentionCounts(client, productIdWanted) {
+	const result = await client.listRequests();
+	const [entry] = summaryOf(result.data.filter(inProduct(productIdWanted)).filter((row) => row["kind"] !== "license_review"));
 	return {
 		open: entry ? Number(entry["open"]) : 0,
 		byKind: entry ? entry["byKind"] : {},
-		...entry && typeof entry["stale"] === "number" ? { stale: entry["stale"] } : {},
-		...snoozed > 0 ? { snoozed } : {},
-		...unchecked > 0 ? { staleNote: `${unchecked} review${unchecked === 1 ? " was" : "s were"} not checked for staleness and count as open.` } : {}
+		...result.truncated ? { note: "The read stopped at its cap, so these may undercount." } : {}
 	};
 }
-/** An item the team has not put off: the page hides one until its snooze ends, and so does this. */
-function isDue(row, now) {
-	return !(row["status"] === "snoozed" && typeof row["snoozedUntil"] === "string" && Date.parse(row["snoozedUntil"]) > now);
-}
-/** Pages read for the summary; past this it says it counted only those. */
-const SUMMARY_PAGE = 100;
 /** Rows an org-wide first page carries when the caller names no limit: the summary answers the rest. */
 const ORG_WIDE_ROWS = 10;
-/** Pages the summary reads before it says it stopped: 1,000 items. */
-const SUMMARY_PAGES = 10;
-/** Every item the summary counts, up to SUMMARY_PAGES pages; nextCursor set when it stopped short. Null on failure. */
-async function everyItem(client, query, orNull = true) {
-	const data = [];
-	let cursor;
-	try {
-		for (let index = 0; index < SUMMARY_PAGES; index += 1) {
-			const page = await client.listInbox({
-				...query,
-				limit: SUMMARY_PAGE,
-				cursor
-			});
-			data.push(...page.data);
-			if (!page.nextCursor) return {
-				data,
-				nextCursor: null
-			};
-			cursor = page.nextCursor;
-		}
-		return {
-			data,
-			nextCursor: cursor ?? null
-		};
-	} catch (error) {
-		if (orNull && (error instanceof TaigaApiError || isNetworkFailure(error))) return null;
-		throw error;
-	}
-}
 const SETUP_TASK_FIELDS = [
 	"id",
 	"productId",
@@ -38930,7 +38808,7 @@ const SETUP_TASK_FIELDS = [
 	"title",
 	"providerDocUrl",
 	"providerActionUrl",
-	"inboxItemId",
+	"requestId",
 	"inboxItemStatus",
 	"createdAt",
 	"stale"
@@ -38939,6 +38817,16 @@ const SETUP_TASK_FIELDS = [
 function totalOf(result) {
 	return typeof result.totalCount === "number" ? { totalCount: result.totalCount } : {};
 }
+/** A setup task row in the glossary's words: the Action Required item it is, by the name taiga_resolve_action takes. */
+function setupTaskRow(row) {
+	const { requestId, inboxItemStatus, alsoFiledAs, ...rest } = row;
+	return {
+		...rest,
+		...requestId ? { actionId: requestId } : {},
+		...inboxItemStatus !== void 0 ? { actionStatus: inboxItemStatus } : {},
+		...Array.isArray(alsoFiledAs) ? { alsoFiledAs: alsoFiledAs.map(setupTaskRow) } : {}
+	};
+}
 /**
 * One row per variable: tasks filed before the API merged a key's categories
 * (PRO-2782) still list JWT_SECRET once as a secret and once as an env_var.
@@ -38967,7 +38855,7 @@ function sameKeyOnce(rows) {
 			id: from["id"],
 			category: from["category"],
 			title: from["title"],
-			inboxItemId: from["inboxItemId"],
+			requestId: from["requestId"],
 			inboxItemStatus: from["inboxItemStatus"]
 		});
 		if (!isOpen(kept) && isOpen(row)) {
@@ -38992,71 +38880,32 @@ function registerInboxTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
 	server.registerTool("taiga_list_action_required", {
 		title: "List what needs a person",
-		description: "List what waits on a person (Action Required): reviews to make and setup only a person can do. The first page opens with a summary by product and kind; rows say how long each has waited and which read opens it (readWith). Across every product (10 rows by default) or one; kind and category narrow it, resolved: true reads what was done. For a key that can change the approved license list, the first page also lists licenseReviews: licenses in use in a product that nobody approved.",
+		description: "List what waits on a person (Action Required): reviews to make and setup only a person can do. Opens with a summary by product and kind; rows say how long each has waited and which read opens it (readWith). Across every product (10 rows by default) or one; kind and category narrow it, resolved: true reads what closed in the last two weeks. For a key that can change the approved license list, it also lists licenseReviews: licenses in use in a product that nobody approved.",
 		inputSchema: object({
 			productId: productId.optional(),
 			category: _enum(["gate", "setup"]).optional().describe("gate: things to review; setup: things to set up"),
-			kind: _enum(KINDS_SAID).optional().describe("Only this kind, such as review_plan or review_pr, as the rows name it"),
-			resolved: boolean().optional().describe("Read the resolved archive (done and dismissed) instead"),
-			full: boolean().optional().describe("Carry each item's metadata, such as a document decision's whole text (default false)"),
-			...pagination
+			kind: _enum(LISTED_KINDS).optional().describe("Only this kind, such as plan_review or setup"),
+			resolved: boolean().optional().describe("Read what closed in the last two weeks instead"),
+			full: boolean().optional().describe("Carry each request's facts and its answers (default false)"),
+			limit: number$1().int().min(1).max(200).optional().describe("Max rows (default 10 across products, every row for one product)")
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const { resolved, full, kind, ...rest } = params;
-		const query = {
-			...rest,
-			...kind ? { kind: KIND_FROM_SAID[kind] ?? kind } : {},
-			...resolved ? { resolved: true } : {}
-		};
-		const first = params.cursor === void 0;
-		const limit = params.limit ?? (params.productId ? void 0 : ORG_WIDE_ROWS);
-		const result = await client.listInbox({
-			...query,
-			...limit !== void 0 ? { limit } : {},
-			...first ? { withTotal: true } : {}
-		});
-		const overview = !first || resolved ? null : !result.nextCursor ? result : await everyItem(client, query);
+		const { resolved, full, kind, category, limit } = params;
+		const result = resolved ? await client.listDoneRequests() : await client.listRequests();
 		const now = Date.now();
-		const due_ = (row) => isDue(row, now);
-		const rows = result.data;
-		const due = rows.filter(due_);
-		const hidden = rows.length - due.length;
-		const overviewDue = overview ? overview.data.filter(due_) : [];
-		const checked = resolved ? {
-			stale: /* @__PURE__ */ new Map(),
-			unchecked: 0,
-			uncheckedIds: /* @__PURE__ */ new Set()
-		} : await staleReviews(client, [...due, ...overviewDue]);
-		const stale = checked.stale;
-		const licences = first && !resolved && !kind && !params.category ? await licenseReviews(client, params.productId, now) : null;
+		const here = result.data.filter(inProduct(params.productId));
+		const licences = here.filter((row) => row["kind"] === "license_review");
+		const asRows = resolved || kind === "license_review";
+		const rows = here.filter((row) => asRows || row["kind"] !== "license_review").filter((row) => kind === void 0 || row["kind"] === kind).filter((row) => category === void 0 || row["kind"] === "setup" === (category === "setup"));
+		const shown = limit ?? (params.productId ? void 0 : ORG_WIDE_ROWS);
+		const backlogRead = client.hasCapability("backlog:read");
 		return toolResult({
-			...overview ? {
-				summary: summaryOf(overviewDue, stale),
-				...overview.nextCursor ? { summaryNote: `The summary counts the first 1000 items` + (params.productId ? "." : "; productId narrows it to one product.") } : {}
-			} : {},
-			...page(due.map((row) => {
-				const item = itemRow(row, now, full === true, client.hasCapability("backlog:read"));
-				const why = stale.get(String(row["id"]));
-				if (why) return {
-					...item,
-					stale: why
-				};
-				return checked.uncheckedIds.has(String(row["id"])) ? {
-					...item,
-					staleChecked: false
-				} : item;
-			}), result.nextCursor),
-			...totalOf(result),
-			...overview && typeof result.totalCount === "number" && (stale.size > 0 || overview.data.length > overviewDue.length || overview.nextCursor) ? { totalNote: "totalCount counts every item, stale and snoozed ones too; summary.open does not" + (overview.nextCursor ? `, and counts only the first 1000.` : ".") } : {},
-			...hidden > 0 ? { snoozedHidden: hidden } : {},
-			...licences && licences.rows.length > 0 ? { licenseReviews: licences.rows } : {},
-			...licences?.truncated ? { licenseReviewsNote: "The requests read stopped at its cap, so some licence reviews may be missing here; the web's Action required lists them all." } : {},
-			...checked.unchecked > 0 ? (() => {
-				const onPage = due.filter((row) => checked.uncheckedIds.has(String(row["id"]))).length;
-				const beyond = checked.unchecked - onPage;
-				return { staleNote: `${[...onPage > 0 ? [`${onPage} review${onPage === 1 ? "" : "s"} on this page could not be checked for whether the subject moved on: those rows say staleChecked: false, and their readWith read tells`] : [], ...beyond > 0 ? [`${beyond} review${beyond === 1 ? "" : "s"} past this page could not be checked, so the summary counts them as open`] : []].join("; ")}.` };
-			})() : {}
+			...resolved ? {} : { summary: summaryOf(rows) },
+			data: rows.slice(0, shown).map((row) => requestRow(row, now, backlogRead, full === true)),
+			totalCount: rows.length,
+			...!resolved && !kind && !category && licences.length > 0 ? { licenseReviews: licences.map((row) => licenseRow(client, row, now)) } : {},
+			...result.truncated ? { truncatedNote: "The read stopped at its cap of 200, so some requests may be missing here and totalCount may undercount." } : {}
 		});
 	}));
 	server.registerTool("taiga_list_setup_tasks", {
@@ -39082,24 +38931,19 @@ function registerInboxTools(server, client) {
 	}));
 	if (!client.hasCapability("products:write")) return;
 	server.registerTool("taiga_resolve_action", {
-		title: "Resolve or snooze an Action Required item",
-		description: "Mark an Action Required item done, dismissed or in progress, or snooze it, for everybody. Resolving a review approves or merges nothing: answer the plan or pull request itself. Marking the documents review done records, in your name, that a person read them: only when they say so.",
+		title: "Answer an Action Required request",
+		description: "Answer a request for everybody: a setup task as done or dismiss, a document, findings or violations as reviewed, a license review as dismiss. Answering approves or merges nothing: answer the plan or pull request itself, and resume a stopped initiative with taiga_resume_initiative. reviewed records, in your name, that a person read it: only when they say so.",
 		inputSchema: object({
-			actionId: idInput("Action Required item", "taiga_list_action_required gives it"),
-			status: _enum([
-				"in_progress",
+			actionId: idInput("Action Required request", "taiga_list_action_required gives it"),
+			answer: _enum([
 				"done",
-				"dismissed"
-			]).optional().describe("What became of it"),
-			snoozedUntil: string$2().datetime().meta({ pattern: void 0 }).nullable().optional().describe("Hide it until this time (ISO 8601 in UTC, ending in Z); null wakes it now")
+				"dismiss",
+				"reviewed"
+			]).describe("The answer, among those the request offers")
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		if (params.status === void 0 && params.snoozedUntil === void 0) return toolError("VALIDATION_ERROR", "Say what became of the item (status) or until when to snooze it.");
-		return toolResult(pickFields([(await client.updateInboxItem(params.actionId, {
-			...params.status !== void 0 ? { status: params.status } : {},
-			...params.snoozedUntil !== void 0 ? { snoozedUntil: params.snoozedUntil } : {}
-		})).data], ITEM_FIELDS)[0]);
+		return toolResult((await client.answerRequest(params.actionId, params.answer)).data);
 	}));
 }
 //#endregion
@@ -39418,15 +39262,11 @@ const CONTEXT_RUN_SAID = [
 ];
 /**
 * What waits on a person for this product, counted as taiga_list_action_required's summary counts it (PRO-2800):
-* the reviewing agent called four tools to answer "how does it stand", and two later reviews found this count and
-* the list's disagree (18 open here, 16 there), because this one counted stale reviews and put-off items as open.
+* the reviewing agent called four tools to answer "how does it stand". A failed read throws, so the part is listed
+* under unavailable like every other part.
 */
-async function attentionPart(client, productId) {
-	const result = await everyItem(client, { productId }, false);
-	return {
-		...await attentionCounts(client, result.data),
-		...result.nextCursor ? { note: "These count the first 1000 items; taiga_list_action_required pages the rest." } : {}
-	};
+function attentionPart(client, productId) {
+	return attentionCounts(client, productId);
 }
 /** The latest sweep and what it left open, as counts; taiga_list_findings lists them. */
 async function maintenancePart(client, productId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.36.0-rc.933",
+  "version": "0.37.0-dev.940",
   "description": "Taiga for AI coding assistants: read products, policies, initiatives and runs, and operate the line, over MCP",
   "mcpName": "ga.tai/mcp-server",
   "license": "UNLICENSED",