@taiga-ai/mcp-server 0.18.0-dev.450 → 0.19.0-dev.451

package/dist/index.js

@@ -480,6 +480,10 @@ var TaigaClient = class {
 	async refreshRealityDocuments(productId, docTypes) {
 		return this.request("POST", `/products/${seg(productId)}/documents/refresh-reality`, docTypes ? { docTypes } : void 0);
 	}
+	/** What still blocks finishing setup: required documents unpublished, required checks unstamped (PRO-2800). */
+	async getProductSetupBlockers(productId) {
+		return this.request("GET", `/products/${seg(productId)}/setup`);
+	}
 	async completeSetup(productId) {
 		return this.request("POST", `/products/${seg(productId)}/setup/complete`);
 	}
@@ -1253,6 +1257,40 @@ function runDisposition(status) {
 	return RUN_DISPOSITION[status];
 }
 /**
+* How the run stands, WITH the fact that decides what 'completed' meant.
+*
+* `completed` WAS one word for two outcomes, and the difference is the whole
+* question for anything that waits on a merge:
+*
+*   - the pull request merged (`completeMergedRun`, from the merge webhook),
+*     which is the run succeeding; or
+*   - the review loop converged with nothing left to push, which settled the
+*     run on a pull request that was still open, possibly failing, and
+*     definitely not in main.
+*
+* The second outcome is no longer produced (PRO-1131): a review never settles a
+* run terminal now, so `completed` is written only by `completeMergedRun` and
+* means merged. This function is NOT therefore redundant -- runs settled under
+* the old rule are still in the table, unmigrated, and keep their status. It
+* remains the only honest answer to "did this land" for any row, whenever it
+* was written.
+*
+* `runDisposition` cannot tell them apart -- it only has the status -- so it
+* calls both 'succeeded'. Every caller that actually means "did this land"
+* must use THIS function instead, which is why it lives next to the map rather
+* than in the one module that first needed it.
+*
+* `prMerged` is a monotonic latch on the run row (a pull request cannot
+* un-merge), and the merge webhook writes it BEFORE it writes the status, so
+* 'completed' with `prMerged: false` is never a window -- it is the second
+* outcome, every time.
+*/
+function dispositionOf(status, prMerged) {
+	const disposition = runDisposition(status);
+	if (disposition === "succeeded" && !prMerged) return "unmerged";
+	return disposition;
+}
+/**
 * Statuses where the coding agent (or review worker) is actively executing.
 * Single source of truth shared by the tenant build feed's `active=true` filter
 * (api) and the dashboard's "running" detection (web), which must agree.
@@ -2074,7 +2112,7 @@ function productDocumentName(type) {
 /** The organization documents that are not policies: goals, standards, voice, instructions. */
 const OTHER_TENANT_DOCUMENT_TYPES = TENANT_DOCUMENT_TYPES.filter((type) => !POLICY_TYPES.includes(type));
 /** `a, b, c` for a description. */
-function named(types) {
+function named$1(types) {
 	return types.join(", ");
 }
 /**
@@ -2165,15 +2203,14 @@ const DISCOVERY_STEP_MEANING = "discoveryStep is where a product in setup is: co
 //#region src/tools/hints.ts
 /**
 * The next step after the API answers 404. The API's own word is bare
-* ("Backlog item not found", "Repository link not found"), and an agent that
+* ("Initiative not found", "Repository link not found"), and an agent that
 * hears only that guesses another ID, or a name. Each ID a tool takes names
 * the tool that lists the right ones; the tool's arguments say which apply.
 */
-const ITEM_ID_HINT = "taiga_list_backlog_items lists a product's initiatives with their IDs; a run or plan ID is not one.";
+const ITEM_ID_HINT = "taiga_list_initiatives lists a product's initiatives with their IDs; a run or plan ID is not one.";
 const BY_ARGUMENT = {
-	itemId: ITEM_ID_HINT,
-	backlogItemId: "taiga_list_backlog_items lists a product's initiatives with their IDs.",
-	buildId: "taiga_list_builds lists the runs, of one product or of every product the key can see.",
+	initiativeId: ITEM_ID_HINT,
+	runId: "taiga_list_runs lists the runs, of one product or of every product the key can see.",
 	planId: "taiga_get_plan gives the initiative's active plan and its ID.",
 	repositoryId: "taiga_list_product_repositories lists the product's repository links; a GitHub repository id is not a link ID.",
 	replacesRepositoryId: "taiga_list_product_repositories lists the product's repository links.",
@@ -2190,17 +2227,41 @@ const BY_ARGUMENT = {
 /** Where an argument means something else on one tool, or the tool's 404 needs its own word. */
 const BY_TOOL = {
 	taiga_resolve_action: () => "taiga_list_action_required lists the items with their IDs.",
-	taiga_get_plan: (said) => /\bplan\b/i.test(said) ? "taiga_get_backlog_item says whether one is being generated (planningStatus planning) or failed, and taiga_plan_again asks for a new one." : ITEM_ID_HINT
+	taiga_get_plan: (said) => /\bplan\b/i.test(said) ? "taiga_get_initiative says whether one is being generated (planningStatus planning) or failed, and taiga_plan_again asks for a new one." : ITEM_ID_HINT
+};
+/**
+* What the API calls the thing each ID names, as its 404 says it ("Environment
+* not found"). A tool given a right product and a wrong environment hinted
+* at both, and the product's hint told the agent its correct product ID was
+* the mistake (PRO-2800): a 404 that names its thing gets that ID's hint only.
+*/
+const MISSING_THING = {
+	initiativeId: /backlog item|initiative/i,
+	runId: /\b(build )?run\b/i,
+	planId: /\bplan\b/i,
+	repositoryId: /repository link|\blink\b/i,
+	replacesRepositoryId: /repository link|\blink\b/i,
+	githubRepositoryId: /github repository/i,
+	installationId: /installation|account/i,
+	jobId: /\bjob\b/i,
+	factoryId: /factory|team/i,
+	findingId: /finding/i,
+	violationId: /violation/i,
+	environmentId: /environment/i,
+	knowledgeId: /knowledge|document/i,
+	productId: /\b(product|project) not found/i
 };
-/** The hint for a 404 from one tool call: the tool's own, else one per ID it was given. */
+/** The hint for a 404 from one tool call: the tool's own, else the one for the ID the API says is missing. */
 function notFoundHint(tool, args) {
 	if (BY_TOOL[tool]) return BY_TOOL[tool];
 	if (typeof args !== "object" || args === null) return void 0;
 	const given = Object.keys(args).filter((key) => args[key] != null && BY_ARGUMENT[key]);
 	given.sort((a, b) => Number(a === "productId") - Number(b === "productId"));
 	if (given.length === 0) return void 0;
-	const hint = given.map((key) => BY_ARGUMENT[key]).join(" ");
-	return () => hint;
+	return (said) => {
+		const named = given.filter((key) => MISSING_THING[key]?.test(said));
+		return (named.length > 0 ? named : given).map((key) => BY_ARGUMENT[key]).join(" ");
+	};
 }
 /** The hint of the tool call in progress, read by runTool when the API answers 404. */
 const notFoundHints = new AsyncLocalStorage();
@@ -2215,11 +2276,45 @@ function withStop(text) {
 }
 //#endregion
 //#region src/tools/errors.ts
+/**
+* The API's names for the two IDs an agent chains most, in the product's
+* words the tools take them in (PRO-2800): a row says initiativeId and runId,
+* as taiga_get_initiative and taiga_get_run ask for them, rather than the
+* storage names backlogItemId and buildRunId.
+*/
+const PRODUCT_WORDS = {
+	backlogItemId: "initiativeId",
+	buildRunId: "runId"
+};
+/**
+* Maps whose keys are content, not API fields: a document's sections are keyed
+* by ids a person or agent chose (a section may be called backlogItemId), and
+* metadata and settings hold whatever their writer put there. Copied as they
+* are, keys and all.
+*/
+const OPAQUE_MAPS = /* @__PURE__ */ new Set([
+	"sections",
+	"metadata",
+	"settings"
+]);
+/** A copy of an API value with its keys in the product's words, values untouched. */
+function inProductWords(value) {
+	if (Array.isArray(value)) return value.map(inProductWords);
+	if (value === null || typeof value !== "object") return value;
+	const out = {};
+	for (const [key, inner] of Object.entries(value)) Object.defineProperty(out, PRODUCT_WORDS[key] ?? key, {
+		value: OPAQUE_MAPS.has(key) ? inner : inProductWords(inner),
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return out;
+}
 /** A successful tool result: one JSON text block the model reads. */
 function toolResult(value) {
 	return { content: [{
 		type: "text",
-		text: JSON.stringify(value, null, 2)
+		text: JSON.stringify(inProductWords(value), null, 2)
 	}] };
 }
 /**
@@ -2234,7 +2329,7 @@ function toolError(error, message, details) {
 			text: JSON.stringify(details ? {
 				error,
 				message,
-				details
+				details: inProductWords(details)
 			} : {
 				error,
 				message
@@ -2486,7 +2581,7 @@ function budgetSections(doc, budget) {
 * The `sections` input of a document read: some sections by id, none for the
 * outline (every id with its size and no text), or omitted for the whole.
 */
-const sectionsInput = z.array(z.string().min(1).max(200)).max(50).optional().describe("Only these sections, by id; [] for the outline (every section id and its size, no text); omit for the whole document");
+const sectionsInput = z.array(z.string().min(1).max(200)).max(50).optional().describe("Only these sections, by id; [] for the outline (under outline: every section id and its size, no text); omit for the whole document");
 /**
 * The answer to a read that names sections: the ones the document has, the
 * rest listed with their sizes, and the asked-for ids it lacks under
@@ -2500,6 +2595,14 @@ function sectionReadResult(doc, ids, label) {
 	if (!cut) return toolError("VALIDATION_ERROR", `The ${label} is not made of sections; read it without sections.`);
 	const all = Object.keys(sectionsOf(doc.data) ?? {});
 	const unknownSections = ids.filter((id) => !all.includes(id));
+	if (ids.filter((id) => all.includes(id)).length === 0) {
+		const { data: _data, ...meta } = cut.doc;
+		return toolResult({
+			...meta,
+			outline: cut.omittedSections,
+			...unknownSections.length > 0 ? { unknownSections } : {}
+		});
+	}
 	return toolResult({
 		...cut.doc,
 		omittedSections: cut.omittedSections,
@@ -2507,6 +2610,90 @@ function sectionReadResult(doc, ids, label) {
 	});
 }
 //#endregion
+//#region src/tools/readiness.ts
+const IMPORT_STATE = {
+	pending: "not started",
+	analyzing: "running",
+	generating_docs: "running",
+	complete: "complete",
+	failed: "failed",
+	cancelled: "failed"
+};
+/** A failure that is the API's (refused, missing, unreachable), not a bug in this code. */
+function isApiSide(error) {
+	return error instanceof TaigaApiError || isNetworkFailure(error);
+}
+/** The documents by the names the web uses. */
+function named(types) {
+	return types.map((type) => PRODUCT_DOCUMENT_NAMES[type] ?? type).join(", ");
+}
+/** The product's setup readiness, or null once it has finished setup. */
+async function setupReadiness(client, product) {
+	if (product["status"] !== "draft") return null;
+	const id = String(product["id"]);
+	const imported = isImportedProduct(product);
+	const [repos, blockers, full] = await Promise.all([
+		client.listProductRepositories(id).then((result) => result.data, (error) => {
+			if (isApiSide(error)) return null;
+			throw error;
+		}),
+		client.getProductSetupBlockers(id).then((result) => result.data, (error) => {
+			if (isApiSide(error)) return null;
+			throw error;
+		}),
+		"discoveryStep" in product || imported ? Promise.resolve(product) : client.getProduct(id).then((result) => result.data, (error) => {
+			if (isApiSide(error)) return product;
+			throw error;
+		})
+	]);
+	const link = repos?.[0];
+	const repository = !repos ? null : link ? {
+		linked: true,
+		name: link["repositoryName"],
+		branch: link["effectiveBranch"]
+	} : { linked: false };
+	const settings = product["settings"] ?? {};
+	const importState = imported ? IMPORT_STATE[String(settings.importStatus)] ?? "not started" : void 0;
+	const missing = blockers ? blockers.missingDocuments : null;
+	const openChecks = blockers ? blockers.openChecks.map((check) => check.criterion) : null;
+	return {
+		ready: blockers ? missing.length === 0 && openChecks.length === 0 : null,
+		repository,
+		...importState ? { import: importState } : {},
+		...imported ? {} : { discoveryStep: full["discoveryStep"] ?? null },
+		missingDocuments: missing ? missing.map((type) => named([type])) : null,
+		openChecks,
+		nextStep: nextStepFor({
+			imported,
+			importState,
+			linked: repository?.linked ?? null,
+			missing,
+			openChecks,
+			product: full
+		})
+	};
+}
+function nextStepFor(state) {
+	const finish = "taiga_finish_discovery opens the product and locks its documents (ask the person: it is their decision that the documents are right).";
+	if (state.imported) {
+		if (state.linked === false) return "Link its repository (taiga_list_linkable_repositories, then taiga_link_repository), then taiga_start_import.";
+		if (state.linked === null && state.importState === "not started") return setupNextStep(state.product);
+		switch (state.importState) {
+			case "running": return "The import is running and derives the documents from the code; taiga_wait_for_job follows it.";
+			case "failed": return "The last import did not finish: taiga_start_import runs it again.";
+			case "complete":
+				if (state.missing && state.missing.length > 0) return `The import finished but ${named(state.missing)} ${state.missing.length === 1 ? "is" : "are"} not published: taiga_list_product_documents shows them, taiga_publish_product_document publishes a draft.`;
+				return `The import is done: review the reality documents (taiga_list_product_documents), then ${finish}`;
+			default: return "taiga_start_import derives the documents from the code and runs by itself (paid agent work: ask first).";
+		}
+	}
+	if (!state.missing) return setupNextStep(state.product);
+	if (state.missing.includes("specification")) return "The specification comes from the Discovery conversation, held in the web: the person describes the product there. The other documents follow from it." + (state.linked === false ? " Linking a repository (taiga_link_repository) can wait until before the first build." : "");
+	if (state.missing.length > 0) return `Still to publish: ${named(state.missing)}. taiga_generate_product_documents generates the missing ones (paid agent work: ask first); a draft is published with taiga_publish_product_document.`;
+	if (state.openChecks && state.openChecks.length > 0) return `The documents are published; the checks are stamped in the web, then ${finish}`;
+	return `Every required document is published: ${finish}`;
+}
+//#endregion
 //#region src/tools/summarize.ts
 /**
 * Keep only the named fields of each item. List tools return summaries (the
@@ -2828,7 +3015,7 @@ function registerProductTools(server, client) {
 		}));
 		server.registerTool("taiga_get_product", {
 			title: "Get product",
-			description: "Get one product in full, by ID or by slug: name, slug, factory, what Taiga owns for it (application, infrastructure, deployment) and its settings; the list and resolve tools carry summaries; taiga_get_product_context carries this summary with the rest a session starts from. Use taiga_list_product_documents for its specification and design, taiga_list_backlog_items for its work and taiga_list_builds for what the coding agent did. A product still in setup carries nextStep: what it waits for and the call that moves it on.",
+			description: "Get one product in full, by ID or by slug: name, slug, factory, what Taiga owns for it (application, infrastructure, deployment) and its settings; the list and resolve tools carry summaries; taiga_get_product_context carries this summary with the rest a session starts from. Use taiga_list_product_documents for its specification and design, taiga_list_initiatives for its work and taiga_list_runs for what the coding agent did. A product still in setup carries readiness: whether it can finish setup now, its repository and import, the required documents not yet published, the checks not yet stamped, and nextStep, the one move that gets it closer.",
 			inputSchema: z.object({
 				productId: productId.optional(),
 				slug: slug.optional()
@@ -2837,10 +3024,10 @@ function registerProductTools(server, client) {
 		}, (params) => runTool(async () => {
 			const resolved = await resolveProductRef(client, params, ["productId", "slug"]);
 			if ("refusal" in resolved) return toolError(resolved.refusal.code, resolved.refusal.message);
-			const nextStep = setupNextStep(resolved.product);
-			return toolResult(nextStep ? {
+			const readiness = await setupReadiness(client, resolved.product);
+			return toolResult(readiness ? {
 				...resolved.product,
-				nextStep
+				readiness
 			} : resolved.product);
 		}));
 		server.registerTool("taiga_resolve_product", {
@@ -2937,7 +3124,7 @@ function sectionIdFrom(readTool) {
 	return z.string().min(1).describe(`Section id -- the keys of \`data.sections\` in ${readTool}, e.g. summary, scope, apiDesign. An id that does not exist yet adds a section.`);
 }
 const sectionContentInput = z.string().describe("The full new Markdown text of the section; it replaces the old text");
-const tenantDocumentType = z.enum(TENANT_DOCUMENT_TYPES).describe(`Document type: a policy (${named(POLICY_TYPES)}) or ${named(OTHER_TENANT_DOCUMENT_TYPES)}`);
+const tenantDocumentType = z.enum(TENANT_DOCUMENT_TYPES).describe(`Document type: a policy (${named$1(POLICY_TYPES)}) or ${named$1(OTHER_TENANT_DOCUMENT_TYPES)}`);
 /** Everything the model needs back from a write, without the content it already holds. */
 function documentSummary(doc) {
 	const { data, ...rest } = doc;
@@ -2999,7 +3186,7 @@ function registerDocumentTools(server, client) {
 	if (client.hasCapability("tenant:documents:read")) {
 		server.registerTool("taiga_list_documents", {
 			title: "List company documents",
-			description: `List the organization's documents as summaries (type, name, description, version, draft state). The ${POLICY_TYPES.length} policies (${named(POLICY_TYPES)}) define the security, data privacy, SDLC, operations, architecture and compliance rules that apply across all factories and products; the other documents (${named(OTHER_TENANT_DOCUMENT_TYPES)}) carry goals, standards, voice and standing instructions. Use taiga_get_document with the type to read one in full.`,
+			description: `List the organization's documents as summaries (type, name, description, version, draft state). The ${POLICY_TYPES.length} policies (${named$1(POLICY_TYPES)}) define the security, data privacy, SDLC, operations, architecture and compliance rules that apply across all factories and products; the other documents (${named$1(OTHER_TENANT_DOCUMENT_TYPES)}) carry goals, standards, voice and standing instructions. Use taiga_get_document with the type to read one in full.`,
 			inputSchema: z.object({ ...pagination }),
 			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
@@ -3008,7 +3195,7 @@ function registerDocumentTools(server, client) {
 		}));
 		server.registerTool("taiga_get_document", {
 			title: "Get company document",
-			description: "Get the full content of one of the organization's documents, sections included. Use this when you need the security requirements, data handling rules, architecture standards or compliance controls that apply to your code, or the goals, standards and voice the organization has set down. A policy runs to thousands of tokens: name the sections you need (the ids taiga_get_product_context lists for every policy, or sections: [] for the outline) and the read carries only those, listing the rest with their sizes and any id the document lacks (unknownSections). A read that finds no document says which documents are published and whether a draft exists.",
+			description: "Get the full content of one of the organization's documents, sections included. Use this when you need the security requirements, data handling rules, architecture standards or compliance controls that apply to your code, or the goals, standards and voice the organization has set down. A policy runs to thousands of tokens: name the sections you need (the ids taiga_get_product_context lists for every policy, or sections: [] for the outline) and the read carries only those, listing the rest with their sizes and any id the document lacks (unknownSections). A read that finds no document says which documents are published and whether a draft exists. Each section's source says where its text came from (template: Taiga's standard text; overlay-<id>: a jurisdiction or industry overlay; cloud-preset:<providers>: rendered for the organization's clouds) and priority: core marks the sections every organization keeps; neither changes what the section requires.",
 			inputSchema: z.object({
 				type: tenantDocumentType,
 				sections: sectionsInput
@@ -3059,7 +3246,7 @@ function registerDocumentTools(server, client) {
 	if (client.hasCapability("factories:read")) {
 		server.registerTool("taiga_list_factory_documents", {
 			title: "List factory documents",
-			description: `List a factory's documents, published and draft, as summaries (type, name, version, draft state). A factory has one document type, ${named(FACTORY_DOCUMENT_TYPES)}: its free-form standing guidance (domain context, tech preferences, conventions) that applies to every product it owns. Drafts are listed too (isDraft true); an empty list means neither a publication nor a draft exists. Use taiga_get_factory_document to read the full content.`,
+			description: `List a factory's documents, published and draft, as summaries (type, name, version, draft state). A factory has one document type, ${named$1(FACTORY_DOCUMENT_TYPES)}: its free-form standing guidance (domain context, tech preferences, conventions) that applies to every product it owns. Drafts are listed too (isDraft true); an empty list means neither a publication nor a draft exists. Use taiga_get_factory_document to read the full content.`,
 			inputSchema: z.object({
 				factoryId: idInput("factory", "taiga_list_factories (query finds one by name) gives it"),
 				...pagination
@@ -3223,9 +3410,9 @@ function requestPrompt(title, description) {
 }
 //#endregion
 //#region src/tools/queue.ts
-/** How many entries the read names; past this an entry keeps its backlogItemId only. */
+/** How many entries the read names; past this an entry keeps its initiativeId only. */
 const NAMED_ENTRIES = 25;
-const MOVE_ASIDE = "or move it down (taiga_queue_backlog_item with afterId) or off the line (taiga_move_backlog_item) to let the rest pass.";
+const MOVE_ASIDE = "or move it down (taiga_queue_initiative with afterId) or off the line (taiga_move_initiative) to let the rest pass.";
 /**
 * What lifts a halt, in the tools that do it. Read from the halt registry in
 * @taiga/types (how each cause clears, and whether a person may lift it), so
@@ -3235,11 +3422,11 @@ const MOVE_ASIDE = "or move it down (taiga_queue_backlog_item with afterId) or o
 function haltNextStep(cause) {
 	if (cause === "awaiting_plan_review") return "Read the plan with taiga_get_plan, then approve it (taiga_approve_plan) or send it back (taiga_reject_plan).";
 	const spec = cause ? HALT_CAUSES[cause] : void 0;
-	if (!cause || !spec) return `Read the initiative with taiga_get_backlog_item to see why, ${MOVE_ASIDE}`;
+	if (!cause || !spec) return `Read the initiative with taiga_get_initiative to see why, ${MOVE_ASIDE}`;
 	const known = cause;
-	if (canResumeHalt(known)) return `taiga_resume_backlog_item lifts it, ${MOVE_ASIDE}`;
+	if (canResumeHalt(known)) return `taiga_resume_initiative lifts it, ${MOVE_ASIDE}`;
 	if (haltClearsItself(known)) return `It clears when ${spec.clearedWhen}; ${MOVE_ASIDE}`;
-	return `Only taking it off the line clears it (taiga_move_backlog_item): ${spec.clearedWhen}.`;
+	return `Only taking it off the line clears it (taiga_move_initiative): ${spec.clearedWhen}.`;
 }
 /**
 * The entry the line waits on, by the queue's two kinds of blocker
@@ -3313,7 +3500,7 @@ async function queueView(client, product, options = { name: "all" }) {
 				cta: lifecycle.cta
 			} : null,
 			...latestBuild ? {
-				buildId: latestBuild.id,
+				runId: latestBuild.id,
 				prUrl: latestBuild.prUrl ?? null
 			} : {}
 		});
@@ -3330,7 +3517,7 @@ async function queueView(client, product, options = { name: "all" }) {
 		}
 		return row;
 	});
-	const note = unnamed === 0 ? null : !canName ? "Entries carry backlogItemId only: naming them needs backlog:read, which this key lacks." : entries.length > NAMED_ENTRIES ? `Only the first ${NAMED_ENTRIES} entries are named; the rest carry backlogItemId only.` : "An entry whose initiative could not be read carries backlogItemId only; taiga_get_backlog_item reads it.";
+	const note = unnamed === 0 ? null : !canName ? "Entries carry initiativeId only: naming them needs backlog:read, which this key lacks." : entries.length > NAMED_ENTRIES ? `Only the first ${NAMED_ENTRIES} entries are named; the rest carry initiativeId only.` : "An entry whose initiative could not be read carries initiativeId only; taiga_get_initiative reads it.";
 	const line = typeof paused === "string" ? `The line is paused (since ${paused}): nothing is planned or built until a person resumes it.` : null;
 	return {
 		linePaused: paused === null ? null : typeof paused === "string",
@@ -3354,7 +3541,7 @@ async function linePausedSince(client, product) {
 }
 function registerQueueTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
-	server.registerTool("taiga_get_queue", {
+	server.registerTool("taiga_get_line", {
 		title: "Get the product queue",
 		description: "Read a product's queue, the line the coding agent works one initiative at a time: each entry in order with its title, where it is (planning, building, in review) and whose turn it is, a halted entry with why it stopped and what lifts it, linePaused (null when the product could not be read), and waitingOn, one sentence saying what the line is waiting for. The line advances only when the active entry's pull request merges, so an entry waiting on a review holds everything behind it. Use this when a queued initiative is not moving.",
 		inputSchema: z.object({ productId }),
@@ -3363,7 +3550,7 @@ function registerQueueTools(server, client) {
 	if (!client.hasCapability("products:write")) return;
 	server.registerTool("taiga_pause_line", {
 		title: "Pause or resume a product's line",
-		description: "Pause the product's whole line, or resume it. Pausing cancels the plan being written and stops the build in flight where it stands (both are flagged), and nothing more is planned or built; initiatives keep their places. Resuming plans the interrupted initiative again from scratch, carries the interrupted build on from its first incomplete step, and the line picks up where it was; a build you had stopped yourself before pausing stays stopped. Idempotent. Pausing interrupts work and resuming starts it: read taiga_get_queue first to see what it would interrupt, and ask the person.",
+		description: "Pause the product's whole line, or resume it. Pausing cancels the plan being written and stops the build in flight where it stands (both are flagged), and nothing more is planned or built; initiatives keep their places. Resuming plans the interrupted initiative again from scratch, carries the interrupted build on from its first incomplete step, and the line picks up where it was; a build you had stopped yourself before pausing stays stopped. Idempotent. Pausing interrupts work and resuming starts it: read taiga_get_line first to see what it would interrupt, and ask the person.",
 		inputSchema: z.object({
 			productId,
 			paused: z.boolean().describe("true pauses the line, false resumes it")
@@ -3379,6 +3566,243 @@ function registerQueueTools(server, client) {
 	}));
 }
 //#endregion
+//#region src/tools/builds.ts
+/** What a list row needs to say for the model to pick a run to read in full. */
+const BUILD_SUMMARY_FIELDS = [
+	"id",
+	"runNumber",
+	"productId",
+	"backlogItemId",
+	"targetTitle",
+	"planId",
+	"status",
+	"failedReason",
+	"runtime",
+	"repositoryFullName",
+	"branch",
+	"baseBranch",
+	"completedSteps",
+	"totalSteps",
+	"prNumber",
+	"prUrl",
+	"prState",
+	"prDraft",
+	"prMerged",
+	"actions",
+	"createdAt",
+	"startedAt",
+	"completedAt"
+];
+/** What a run says about itself after a stop or a resume: its state and what can be done next. */
+const RUN_OUTCOME_FIELDS = [
+	"id",
+	"runNumber",
+	"backlogItemId",
+	"status",
+	"failedReason",
+	"completedSteps",
+	"totalSteps",
+	"prNumber",
+	"prUrl",
+	"prMerged",
+	"actions"
+];
+/**
+* Where a run that ended without finishing stopped, from its steps and its
+* hardening result: a failed run with every step completed reads as nothing
+* failed, and retry_from_failed_step then reads as a mistake, when the agent
+* stalled in the hardening pass after the steps and the retry continues it.
+* Null for a run still going or that finished.
+*/
+function stoppedIn(run, steps) {
+	if (run.prMerged === true || run.status !== "failed" && run.status !== "stopped") return null;
+	if (!steps.some((step) => step.status !== "planned")) return "before the first step started, while setting up the run (cloning, preparing the workspace)";
+	const open = steps.find((step) => step.status !== "completed" && step.status !== "skipped");
+	if (open) return open.status === "planned" ? `before step ${String(open.stepOrder)}, ${String(open.title)}, started (the ones before it completed)` : `step ${String(open.stepOrder)}, ${String(open.title)} (${String(open.status)})`;
+	if (run.hardeningResult == null) return "after the last step, in hardening: the security scanners and their fixes the agent runs before the pull request is ready. A retry continues from there; the steps stay.";
+	return "after the steps and hardening, at the pull request";
+}
+/**
+* The disposition with the merge latch authoritative: a run whose pull
+* request merged landed, whatever settled status it kept when the completion
+* write after the merge failed (build.ts allows a merged run to stay failed
+* or stopped). A run still executing keeps its in-flight disposition.
+*/
+function landedDisposition(status, prMerged) {
+	const disposition = dispositionOf(status, prMerged);
+	return prMerged && disposition !== "in_flight" ? "succeeded" : disposition;
+}
+/** What each executing status is doing, in a phrase. */
+const RUNNING = {
+	cloning: "setting up the workspace",
+	implementing: "implementing the steps",
+	hardening: "hardening: running the security scanners and fixing what they find",
+	pushing: "pushing the branch",
+	ci_checking: "waiting for the pull request's CI",
+	ci_fixing: "fixing what CI found",
+	reviewing: "answering review comments on the pull request"
+};
+/**
+* How a run stands, in one sentence, with its disposition: the meaning the
+* status and the pull request facts carry between them
+* (PRO-2800). An agent read `closed` with failedReason null, every step
+* completed and hardening passed, and could not tell what had happened; the
+* status alone cannot say whether a completed run merged (dispositionOf).
+*/
+function runOutcome(run) {
+	const status = run["status"];
+	if (!BUILD_RUN_STATUSES.includes(status)) return null;
+	const disposition = landedDisposition(status, run["prMerged"] === true);
+	const pr = typeof run["prNumber"] === "number" ? `PR #${run["prNumber"]}` : "its pull request";
+	const progress = typeof run["completedSteps"] === "number" && typeof run["totalSteps"] === "number" ? ` (${run["completedSteps"]} of ${run["totalSteps"]} steps done)` : "";
+	const reason = typeof run["failedReason"] === "string" && run["failedReason"] ? `: ${run["failedReason"]}` : "";
+	return {
+		disposition,
+		outcome: {
+			in_flight: status === "pending" ? "Queued: waiting to start." : `Running: ${RUNNING[status] ?? status}${progress}.`,
+			gated: `Waiting for a person to review and merge ${pr}.`,
+			succeeded: `Merged: ${pr} is in ${typeof run["baseBranch"] === "string" ? run["baseBranch"] : "the base branch"}.`,
+			unmerged: typeof run["prNumber"] === "number" || run["prUrl"] ? `Settled without merging: ${pr} was left unmerged.` : "Settled without a merged pull request.",
+			failed: `Failed${reason}${progress}.`,
+			stopped: `Stopped before it finished${progress}.`,
+			rejected: `${pr} was closed without merging, so the work did not land.`
+		}[disposition] ?? status
+	};
+}
+/**
+* A run row as an agent reads it: its outcome added, and prDraft only where
+* there is a pull request. The column defaults to true, so a run that never
+* opened one said it had a draft (PRO-2800).
+*/
+function readableRun(run) {
+	const { prDraft, ...rest } = run;
+	const said = runOutcome(run);
+	return {
+		...rest,
+		...typeof rest["prNumber"] === "number" || rest["prUrl"] ? { prDraft } : {},
+		...said ?? {}
+	};
+}
+/** How many products the org-wide list names; past this a row keeps its productId only. */
+const NAMED_PRODUCTS = 100;
+const runId = idInput("run", "taiga_list_runs gives it");
+/** A step without its instructions: what it is, how it stands and what it changed. */
+const STEP_SUMMARY_FIELDS = [
+	"stepOrder",
+	"title",
+	"status",
+	"currentPhase",
+	"commitSha",
+	"filesChanged",
+	"verification",
+	"error",
+	"errorClassification",
+	"startedAt",
+	"completedAt"
+];
+/** Past this many characters a step's headline is cut; the full read has the rest. */
+const HEADLINE_LIMIT = 600;
+/**
+* The first paragraph of a step's summary: the agent writes its result
+* there (what changed, which checks passed), and the detail after it.
+*/
+function summaryHeadline(summary) {
+	if (typeof summary !== "string" || !summary.trim()) return null;
+	const first = summary.trim().split(/\n\s*\n/, 1)[0].trim();
+	return first.length > HEADLINE_LIMIT ? `${first.slice(0, HEADLINE_LIMIT).trimEnd()}...` : first;
+}
+/**
+* The runs of every product the key can see, each row naming its product.
+* The route carries product ids only; one products read names them, and a
+* failure of that read leaves the rows unnamed rather than failing the list.
+*/
+async function activityRows(client, opts) {
+	const [runs, products] = await Promise.all([client.listBuildRunActivity(opts), client.listProducts({ limit: NAMED_PRODUCTS }).catch((error) => {
+		if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
+		throw error;
+	})]);
+	const nameById = /* @__PURE__ */ new Map();
+	for (const product of products?.data ?? []) nameById.set(product.id, {
+		name: product.name,
+		slug: product.slug
+	});
+	const rows = pickFields(runs.data, BUILD_SUMMARY_FIELDS).map(readableRun).map((row) => {
+		const product = nameById.get(String(row["productId"]));
+		return product ? {
+			...row,
+			product
+		} : row;
+	});
+	const note = !rows.some((row) => !("product" in row)) ? null : !products ? "The products could not be read, so rows carry productId only; taiga_get_product names one." : products.nextCursor !== null ? `Only the first ${NAMED_PRODUCTS} products could be named; a row without product carries productId only.` : "A row without product belongs to a product the key cannot list (deleted since, or not visible to it); it carries productId only.";
+	return {
+		...page(rows, runs.nextCursor),
+		...note ? { note } : {}
+	};
+}
+function registerBuildTools(server, client) {
+	if (!client.hasCapability("products:read")) return;
+	server.registerTool("taiga_list_runs", {
+		title: "List runs",
+		description: "List the coding agent's runs, newest first. A run is one attempt at building an initiative: its branch, pull request and step progress. Each row says how it stands in one sentence (outcome) and as a disposition: in_flight (the agent is working), gated (a person owes a review and merge), succeeded (merged), failed, stopped, rejected (the pull request was closed without merging) or unmerged. actions name what a person may do with it. With productId, the runs of that product, optionally of one initiative; without it, the runs of every product the key can see, each row naming its product, and active: true narrows to the runs executing now. taiga_get_run reads one with its steps. Work is carried on from the initiative (taiga_resume_initiative), not the run.",
+		inputSchema: z.object({
+			productId: productId.optional(),
+			initiativeId: idInput("initiative", "taiga_list_initiatives (query finds one by title) gives it").optional().describe("Only this initiative's runs -- get from taiga_list_initiatives; needs productId"),
+			active: z.boolean().optional().describe("Only runs the agent is executing now (cloning through reviewing; a queued pending run is not yet executing and is left out); for the org-wide list"),
+			...pagination
+		}),
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		if (!params.productId && params.initiativeId) return toolError("VALIDATION_ERROR", "initiativeId narrows the runs of one product: pass its productId as well (the initiative carries it).");
+		if (params.productId && params.active) return toolError("VALIDATION_ERROR", "active narrows the org-wide list only: omit productId, or read the product's runs and judge each by its status.");
+		if (params.productId) {
+			const result = await client.listBuildRuns(params.productId, {
+				backlogItemId: params.initiativeId,
+				limit: params.limit,
+				cursor: params.cursor
+			});
+			return toolResult(page(pickFields(result.data, BUILD_SUMMARY_FIELDS).map(readableRun), result.nextCursor));
+		}
+		return toolResult(await activityRows(client, params));
+	}));
+	server.registerTool("taiga_get_run", {
+		title: "Get run",
+		description: "Get one run with its steps: how it stands (outcome, disposition), its pull request and hardening, and each step's title, status, commit, files changed, verification and headline, the first paragraph of what the agent reported. A step's verification is Taiga's own check after the step (tests, lint, build), independent of what the agent says it ran: a docs-only step can show tests failed because the repository's tests fail. A run that failed or was stopped says where (stoppedIn) and when it last made progress (lastProgressAt). Pass full: true for each step's complete instructions and report, several thousand tokens on a long run. Its actions name what the initiative accepts: resume and retry_from_failed_step are taiga_resume_initiative; start_over is in the web only; to stop it, move the initiative out of Build. A maintenance run has no initiative and is retried from its finding.",
+		inputSchema: z.object({
+			runId,
+			full: z.boolean().optional().describe("Carry each step's complete instructions and report (default false: a summary)")
+		}),
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		const [run, steps] = await Promise.all([client.getBuildRun(params.runId), client.listBuildRunSteps(params.runId)]);
+		const runRow = run.data;
+		const rows = steps.data;
+		const where = stoppedIn(runRow, rows);
+		const stop = where ? { stoppedIn: where } : {};
+		if (params.full) return toolResult({
+			...readableRun(runRow),
+			...stop,
+			steps: steps.data
+		});
+		return toolResult({
+			...readableRun(runRow),
+			...stop,
+			steps: pickFields(rows, STEP_SUMMARY_FIELDS).map((step, index) => ({
+				...step,
+				headline: summaryHeadline(rows[index].summary)
+			}))
+		});
+	}));
+	if (!client.hasCapability("products:write")) return;
+	server.registerTool("taiga_stop_run", {
+		title: "Stop a run",
+		description: "The emergency brake: stop a run the coding agent is executing when its initiative cannot be moved. The way to stop work is on the initiative: move it out of Build (taiga_move_initiative), which stops the plan or run in flight. Use this only for a run whose initiative does not offer that (it is finished, canceled or gone) yet the run is still going. The agent halts, its branch and any draft pull request stay. Only a run whose actions include stop; the API refuses the rest with CONFLICT.",
+		inputSchema: z.object({ runId }),
+		annotations: OPERATE
+	}, (params) => runTool(async () => {
+		return toolResult(readableRun(pickFields([(await client.stopBuildRun(params.runId)).data], RUN_OUTCOME_FIELDS)[0]));
+	}));
+}
+//#endregion
 //#region src/tools/backlogs.ts
 /** What a list row needs to say for the model to pick an item to read in full. */
 const BACKLOG_SUMMARY_FIELDS = [
@@ -3414,6 +3838,83 @@ const ITEM_OUTCOME_FIELDS = [
 	"archivedAt",
 	"lifecycle"
 ];
+/** The move each call to action is, in the tools' words. */
+const CTA_MOVE = {
+	start_plan: "taiga_queue_initiative puts it on the line to be planned and built (paid work: ask first)",
+	retry_plan: "taiga_plan_again asks for a new plan (paid work: ask first)",
+	start_build: "read the plan with taiga_get_plan, then taiga_approve_plan builds it or taiga_reject_plan sends it back",
+	resume_build: "taiga_resume_initiative carries the run on (paid work: ask first)",
+	retry_build: "a new run starts over from the web; taiga_move_initiative takes it off the line",
+	review_pr: "a person reviews and merges the pull request",
+	view_pr: "the line merges the pull request once its checks pass"
+};
+/** How a run stands, as the end of "its latest run ...", by disposition. */
+const RUN_STANDS = {
+	in_flight: "is running",
+	gated: "is in review",
+	succeeded: "merged",
+	unmerged: "settled unmerged",
+	failed: "failed",
+	stopped: "was stopped",
+	rejected: "had its pull request closed without merging"
+};
+/** Where an initiative is, in a phrase, by its lifecycle stage. */
+const STAGE = {
+	backlog: "In the backlog, not on the line yet",
+	planning: "Being planned",
+	planned: "Planned",
+	building: "Being built",
+	in_review: "Its pull request is in review",
+	done: "Done",
+	canceled: "Canceled"
+};
+/**
+* Where an initiative stands and what moves it on, in one sentence (PRO-2800).
+* Five fields carried it (status, state, planningStatus, needsHumanCause,
+* lifecycle) and a reviewing agent had to read the queue, the initiative and
+* the run together to say what had happened; the lifecycle the API derives
+* already decides it. Null for a row without a lifecycle.
+*/
+function situationOf(item) {
+	const life = item["lifecycle"];
+	if (!life || typeof life.stage !== "string") return null;
+	const parts = [];
+	let stage = STAGE[life.stage] ?? life.stage;
+	if (life.stage === "planning" && life.turn === "you") stage = `Planning stopped${typeof life.planFailureCause === "string" ? ` (${life.planFailureCause})` : ""}`;
+	const build = life.latestBuild;
+	if (build && typeof build.status === "string" && life.stage !== "done" && life.stage !== "canceled") {
+		const pr = typeof build.prNumber === "number" ? ` (PR #${build.prNumber})` : "";
+		const said = BUILD_RUN_STATUSES.includes(build.status) ? RUN_STANDS[landedDisposition(build.status, build.prMerged === true)] : build.status;
+		stage += `; its latest run ${said}${pr}`;
+	}
+	parts.push(`${stage}.`);
+	if (typeof item["needsHumanCause"] === "string") {
+		const why = [renderHalt({
+			cause: item["needsHumanCause"],
+			params: {}
+		}), typeof item["needsHumanDetail"] === "string" ? item["needsHumanDetail"] : ""].filter(Boolean).map((text) => text.replace(/\.$/, "")).join(". ");
+		if (why) parts.push(`The line stopped on it: ${why}.`);
+	}
+	const turn = life.turn === "you" ? "A person's turn" : life.turn === "agent" ? "The agent's turn" : null;
+	const move = typeof life.cta === "string" ? CTA_MOVE[life.cta] : void 0;
+	if (life.cta === "view_pr") parts.push(`Nothing to do: ${move}.`);
+	else if (turn && move) parts.push(`${turn}: ${move}.`);
+	else if (turn) parts.push(`${turn}.`);
+	else if (move) parts.push(`Next: ${move}.`);
+	return parts.join(" ");
+}
+/** A row or item with its situation added when it has a lifecycle. */
+function withSituation(item, row = item) {
+	const situation = situationOf(item);
+	return situation ? {
+		...row,
+		situation
+	} : row;
+}
+/** List rows, each with its situation. */
+function situatedRows(items) {
+	return itemRows(items, BACKLOG_SUMMARY_FIELDS).map((row, index) => withSituation(items[index], row));
+}
 /** What each plan failure cause means for whoever reads it next (PLAN_FAILURE_CAUSES in @taiga/types). */
 const PLAN_FAILURE_MEANING = {
 	agent_error: "The planning agent failed. Planning again is the usual next step.",
@@ -3425,10 +3926,10 @@ const PLAN_FAILURE_MEANING = {
 * (PRO-2780): planFailureCause alone said "cancelled" with nobody behind it.
 * Best effort: a history the API will not give leaves the item as it was.
 */
-async function planFailureOf(client, itemId, itemCause) {
+async function planFailureOf(client, initiativeId, itemCause) {
 	let events;
 	try {
-		events = (await client.listBacklogItemActivity(itemId)).data;
+		events = (await client.listBacklogItemActivity(initiativeId)).data;
 	} catch (error) {
 		if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
 		throw error;
@@ -3460,7 +3961,7 @@ async function planFailureOf(client, itemId, itemCause) {
 	};
 }
 const planId = idInput("plan", "taiga_get_plan gives the initiative's active plan and its ID");
-const itemId = idInput("backlog item", "taiga_list_backlog_items (query finds one by title) gives it");
+const initiativeId = idInput("initiative", "taiga_list_initiatives (query finds one by title) gives it");
 /** The plan without its steps' prose: enough to approve it or say what a run will do. */
 const PLAN_SUMMARY_FIELDS = [
 	"id",
@@ -3479,8 +3980,8 @@ const PLAN_STEP_SUMMARY_FIELDS = [
 	"reads",
 	"createsResources"
 ];
-/** The outcome fields of an initiative, with how many of its criteria are met. */
-const outcomeOf = (item) => ({
+/** The outcome fields of an initiative, with how many of its criteria are met, and where it stands. */
+const outcomeOf = (item) => withSituation(item, {
 	...pickFields([item], ITEM_OUTCOME_FIELDS)[0],
 	criteria: criteriaCounts(item)
 });
@@ -3515,9 +4016,9 @@ function registerBacklogTools(server, client) {
 	if (may("backlog:read") && may("backlog:write") && may("products:write")) registerPlanAgain(server, client);
 }
 function registerBacklogReads(server, client) {
-	server.registerTool("taiga_list_backlog_items", {
-		title: "List backlog items",
-		description: "List a product's backlog items (initiatives): titles, category, status, where each one is on the line (backlog, todo, queue, plan, build, done) and criteria, how many of its acceptance criteria are met (null before it is planned; met counts the criteria the agent confirmed with evidence or a person checked off, so a done item can show fewer met than it has). Use this to find the item you are working on (query finds one by title), then read its acceptance criteria and technical context with taiga_get_backlog_item. Archived items are left out unless asked for.",
+	server.registerTool("taiga_list_initiatives", {
+		title: "List initiatives",
+		description: "List a product's initiatives, its backlog: titles, category, status, where each one is on the line (backlog, todo, queue, plan, build, done), situation (where it stands and what moves it on, in a sentence) and criteria, how many of its acceptance criteria are met (null before it is planned; met counts the criteria the agent confirmed with evidence or a person checked off, so a done item can show fewer met than it has). Use this to find the item you are working on (query finds one by title), then read its acceptance criteria and technical context with taiga_get_initiative. Archived items are left out unless asked for.",
 		inputSchema: z.object({
 			productId,
 			query: z.string().trim().min(1).max(200).optional().describe("Part of the title, any case: only the items that contain it"),
@@ -3547,7 +4048,7 @@ function registerBacklogReads(server, client) {
 		const { query, ...filters } = params;
 		if (query === void 0) {
 			const result = await client.listBacklogItems(params.productId, filters);
-			return toolResult(page(itemRows(result.data, BACKLOG_SUMMARY_FIELDS), result.nextCursor));
+			return toolResult(page(situatedRows(result.data), result.nextCursor));
 		}
 		if (params.cursor !== void 0) return toolError("VALIDATION_ERROR", SEARCH_WITH_CURSOR);
 		const found = await searchPages((cursor) => client.listBacklogItems(params.productId, {
@@ -3556,35 +4057,36 @@ function registerBacklogReads(server, client) {
 			cursor
 		}), query, (row) => [row.title], params.limit ?? 25);
 		return toolResult({
-			...page(itemRows(found.rows, BACKLOG_SUMMARY_FIELDS), null),
+			...page(situatedRows(found.rows), null),
 			...found.more ? { more: SEARCH_NOTE } : {}
 		});
 	}));
-	server.registerTool("taiga_get_backlog_item", {
-		title: "Get backlog item",
-		description: "Get one backlog item in full: description, acceptance criteria (and which are met), technical context (patterns, constraints, and the assumptions to verify before starting), dependencies and source documents. Read this before implementing an item, and read its runs with taiga_list_builds to see what the coding agent already did. A failed plan carries planFailure: the cause, what it means, when, and by whom. lifecycle says whose turn it is and what moves it on: cta start_plan is taiga_queue_backlog_item, retry_plan taiga_plan_again (planFailureCause says why the plan stopped), start_build taiga_approve_plan, resume_build taiga_resume_backlog_item, retry_build a fresh run (start over, in the web), review_pr and view_pr the pull request. needsHumanCause is set only when the line stopped on it.",
-		inputSchema: z.object({ itemId }),
+	server.registerTool("taiga_get_initiative", {
+		title: "Get initiative",
+		description: "Get one initiative in full: description, acceptance criteria (and which are met), technical context (patterns, constraints, and the assumptions to verify before starting), dependencies and source documents. Read this before implementing an item, and read its runs with taiga_list_runs to see what the coding agent already did. A failed plan carries planFailure: the cause, what it means, when, and by whom. situation says in one sentence where it stands, whose turn it is and the call that moves it on. The same as fields: lifecycle says whose turn it is and what moves it on: cta start_plan is taiga_queue_initiative, retry_plan taiga_plan_again (planFailureCause says why the plan stopped), start_build taiga_approve_plan, resume_build taiga_resume_initiative, retry_build a fresh run (start over, in the web), review_pr and view_pr the pull request. needsHumanCause is set only when the line stopped on it.",
+		inputSchema: z.object({ initiativeId }),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const item = (await client.getBacklogItem(params.itemId)).data;
-		if (item.planningStatus !== "failed") return toolResult(item);
+		const item = (await client.getBacklogItem(params.initiativeId)).data;
+		const row = item;
+		if (item.planningStatus !== "failed") return toolResult(withSituation(row));
 		const ownCause = item.planFailureCause;
-		const planFailure = await planFailureOf(client, params.itemId, ownCause);
-		return toolResult(planFailure ? {
+		const planFailure = await planFailureOf(client, params.initiativeId, ownCause);
+		return toolResult(withSituation(row, planFailure ? {
 			...item,
 			planFailure
-		} : item);
+		} : item));
 	}));
 	server.registerTool("taiga_get_plan", {
 		title: "Get the active plan",
 		description: "Get an initiative's active plan with its steps, in order: each step's title, layer, dependencies (the orderIndex of the steps it builds on), the files it writes and reads and the resources it creates. That is enough to approve or reject it (taiga_approve_plan, taiga_reject_plan) and to say what a run will do; pass full: true for each step's complete instructions, several thousand tokens on a large plan. NOT_FOUND when the initiative has no active plan yet (planningStatus says whether one is being generated).",
 		inputSchema: z.object({
-			itemId,
+			initiativeId,
 			full: z.boolean().optional().describe("Carry each step's complete instructions (default false: a summary)")
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const plan = (await client.getActivePlan(params.itemId)).data;
+		const plan = (await client.getActivePlan(params.initiativeId)).data;
 		if (params.full) return toolResult(plan);
 		const steps = Array.isArray(plan.steps) ? plan.steps : [];
 		return toolResult({
@@ -3615,18 +4117,18 @@ function registerRequest(server, client) {
 	}));
 }
 function registerMove(server, client) {
-	server.registerTool("taiga_move_backlog_item", {
-		title: "Move backlog item on the board",
-		description: `Move an initiative on the board, or order it within a column: backlog and todo are yours and the line never moves an initiative out of them; queue puts it in the line (taiga_queue_backlog_item says more); done and canceled finish it by hand. The queue is the only way to start work: there is no "plan this now", and nothing is moved into Build by a person. Moving an initiative out of Build stops the plan being written or the run in flight: that is how work is stopped, and it throws that work away. A move to ${PR_CLOSING_STATES.join(", ")} CLOSES a pull request the initiative is still waiting on (a move to queue keeps it, and done leaves it to be merged); Taiga leaves a comment on the pull request saying why. The state machine refuses a move that is not allowed (CONFLICT). A move into queue starts paid work and needs products:write. Ask the person before a move that starts work, stops work or closes a pull request. archived: true files the initiative where it stands (pass its current column as state; never from the Build station, plan or build) and archived: false brings it back; archived work is left out of lists unless includeArchived asks for it.`,
+	server.registerTool("taiga_move_initiative", {
+		title: "Move initiative on the board",
+		description: `Move an initiative on the board, or order it within a column: backlog and todo are yours and the line never moves an initiative out of them; queue puts it in the line (taiga_queue_initiative says more); done and canceled finish it by hand. The queue is the only way to start work: there is no "plan this now", and nothing is moved into Build by a person. Moving an initiative out of Build stops the plan being written or the run in flight: that is how work is stopped, and it throws that work away. A move to ${PR_CLOSING_STATES.join(", ")} CLOSES a pull request the initiative is still waiting on (a move to queue keeps it, and done leaves it to be merged); Taiga leaves a comment on the pull request saying why. The state machine refuses a move that is not allowed (CONFLICT). A move into queue starts paid work and needs products:write. Ask the person before a move that starts work, stops work or closes a pull request. archived: true files the initiative where it stands (pass its current column as state; never from the Build station, plan or build) and archived: false brings it back; archived work is left out of lists unless includeArchived asks for it.`,
 		inputSchema: z.object({
-			itemId,
+			initiativeId,
 			state: z.enum(USER_DROP_STATES).describe("The column to move into"),
-			afterId: idInput("backlog item", "taiga_list_backlog_items gives it").nullable().optional().describe("The initiative to follow in that column; null for the head; omit to keep rank order"),
+			afterId: idInput("initiative", "taiga_list_initiatives gives it").nullable().optional().describe("The initiative to follow in that column; null for the head; omit to keep rank order"),
 			archived: z.boolean().optional().describe("true files the initiative where it stands, false brings it back; omit to leave as is")
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		const { itemId: id, ...body } = params;
+		const { initiativeId: id, ...body } = params;
 		if (body.state === "queue" && !client.hasCapability("products:write")) return toolError("FORBIDDEN", "A move into queue starts agent work and needs products:write, which this key lacks.");
 		return outcome((await client.transitionInitiative(id, body)).data);
 	}));
@@ -3636,20 +4138,20 @@ const BUILD_STATION = /* @__PURE__ */ new Set(["plan", "build"]);
 function registerPlanAgain(server, client) {
 	server.registerTool("taiga_plan_again", {
 		title: "Plan an initiative again",
-		description: "Supersede the plan of the initiative at the Build station and ask the planner for a new one: for a plan that failed, a plan you do not want built, or a run whose direction was wrong once it has stopped. The earlier plan is kept, and every run records which plan version it built; a pull request still open stays open. Offered only when the turn is yours: refused (CONFLICT) while an agent holds it (planning, building, reviewing). Also refused while a dependency is still in flight or a UI direction has no chosen concept, unless force says to plan anyway, which only the person decides. Anywhere off the Build station, put the initiative in the queue instead (taiga_queue_backlog_item): the queue is the only way to start work. To send a plan back with direction, taiga_reject_plan. Starts a planner run.",
+		description: "Supersede the plan of the initiative at the Build station and ask the planner for a new one: for a plan that failed, a plan you do not want built, or a run whose direction was wrong once it has stopped. The earlier plan is kept, and every run records which plan version it built; a pull request still open stays open. Offered only when the turn is yours: refused (CONFLICT) while an agent holds it (planning, building, reviewing). Also refused while a dependency is still in flight or a UI direction has no chosen concept, unless force says to plan anyway, which only the person decides. Anywhere off the Build station, put the initiative in the queue instead (taiga_queue_initiative): the queue is the only way to start work. To send a plan back with direction, taiga_reject_plan. Starts a planner run.",
 		inputSchema: z.object({
-			itemId,
+			initiativeId,
 			force: z.boolean().optional().describe("Plan anyway past an unsettled dependency or an unchosen UI direction; only when the person says so")
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		const item = (await client.getBacklogItem(params.itemId)).data;
-		if (!BUILD_STATION.has(String(item.state))) return toolError("CONFLICT", `This initiative is in ${String(item.state)}, not at the Build station. The queue is the only way to start work: put it in the queue with taiga_queue_backlog_item and it is planned when its turn comes.`);
+		const item = (await client.getBacklogItem(params.initiativeId)).data;
+		if (!BUILD_STATION.has(String(item.state))) return toolError("CONFLICT", `This initiative is in ${String(item.state)}, not at the Build station. The queue is the only way to start work: put it in the queue with taiga_queue_initiative and it is planned when its turn comes.`);
 		const body = {
 			state: "plan",
 			...params.force ? { force: true } : {}
 		};
-		return outcome((await client.transitionInitiative(params.itemId, body)).data);
+		return outcome((await client.transitionInitiative(params.initiativeId, body)).data);
 	}));
 }
 /** Whether a failure is the API's (refused, missing, unreachable) rather than a bug here. */
@@ -3693,17 +4195,17 @@ async function placeInQueue(client, item) {
 }
 const autoBuildInput = z.boolean().nullable().describe("false stops the line at this initiative's plan for a person to read it; true builds it as soon as it lands; null follows the product's default");
 function registerQueue(server, client) {
-	server.registerTool("taiga_queue_backlog_item", {
-		title: "Queue backlog item",
-		description: "Add an initiative to the product queue, the line the coding agent works: queued initiatives are planned and built one at a time, each advancing when the previous pull request merges. This starts paid work: a planner run, then a coding run that pushes commits and opens a pull request in the product repository. Whether the plan is built at once or waits for a person is the initiative's review gate: pass autoBuild: false to read the plan before anything is built (the product's default applies otherwise, and the outcome says which it is); the gate is set first and stays set if the move is then refused. Ask the person before calling this. An initiative already in the queue stays where it is unless afterId says where to go; one being planned or built cannot move (CONFLICT). Returns the initiative with its new state, its review gate and its place in the queue.",
+	server.registerTool("taiga_queue_initiative", {
+		title: "Queue initiative",
+		description: "Add an initiative to the product queue, the line the coding agent works: queued initiatives are planned and built one at a time, each advancing when the previous pull request merges. This starts paid work: a planner run, then a coding run that pushes commits and opens a pull request in the product repository. Whether the plan is built at once or waits for a person is the initiative's review gate: pass autoBuild: false to read the plan before anything is built (the product's default applies otherwise, and the outcome says which it is); the gate is set first and stays set if the move is then refused. An initiative already in the queue stays where it is unless afterId says where to go; one being planned or built cannot move (CONFLICT). Returns the initiative with its new state, its review gate and its place in the queue.",
 		inputSchema: z.object({
-			itemId,
-			afterId: idInput("backlog item", "taiga_list_backlog_items gives it").nullable().optional().describe("The queued initiative to follow; null for the head of the queue; omit to append a new entry or leave a queued one where it is"),
+			initiativeId,
+			afterId: idInput("initiative", "taiga_list_initiatives gives it").nullable().optional().describe("The queued initiative to follow; null for the head of the queue; omit to append a new entry or leave a queued one where it is"),
 			autoBuild: autoBuildInput.optional().describe("Set the initiative's review gate before queueing: false to read the plan first, true to build it at once, null to follow the product; omit to leave the gate as it is")
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		const { itemId: id, autoBuild, ...placement } = params;
+		const { initiativeId: id, autoBuild, ...placement } = params;
 		if (autoBuild !== void 0) await client.setAutoBuild(id, autoBuild);
 		const item = (await client.transitionInitiative(id, {
 			state: "queue",
@@ -3714,7 +4216,7 @@ function registerQueue(server, client) {
 			...outcomeOf(item),
 			reviewGate: gate,
 			queue,
-			...gate && queue ? {} : { note: "Part of the outcome could not be read; taiga_get_queue and taiga_get_product say the rest." }
+			...gate && queue ? {} : { note: "Part of the outcome could not be read; taiga_get_line and taiga_get_product say the rest." }
 		});
 	}));
 }
@@ -3723,12 +4225,12 @@ function registerReviewGate(server, client) {
 		title: "Set an initiative's review gate",
 		description: "Set whether an initiative's plan is built as soon as it lands (true) or waits for a person to read it and approve or reject it (false); null follows the product's default. Standing: it applies to every plan the initiative gets, including one being written now. Opening the gate on a plan that is already waiting starts its build at once. Returns the initiative with the gate that now applies.",
 		inputSchema: z.object({
-			itemId,
+			initiativeId,
 			autoBuild: autoBuildInput
 		}),
 		annotations: OPERATE_SETTING
 	}, (params) => runTool(async () => {
-		const item = (await client.setAutoBuild(params.itemId, params.autoBuild)).data;
+		const item = (await client.setAutoBuild(params.initiativeId, params.autoBuild)).data;
 		const gate = await reviewGate(client, item);
 		return toolResult({
 			...outcomeOf(item),
@@ -3738,12 +4240,12 @@ function registerReviewGate(server, client) {
 	}));
 }
 function registerResume(server, client) {
-	server.registerTool("taiga_resume_backlog_item", {
-		title: "Resume backlog item",
+	server.registerTool("taiga_resume_initiative", {
+		title: "Resume initiative",
 		description: "Resume an initiative the line stopped on, which is when needsHumanCause is set (the line sets it): a failed or cancelled plan is planned again, a stopped or failed run resumes from its first unfinished part (the steps already committed are kept), a refused build start is cleared and retried. This is the way to carry work on: a run is the record of an attempt, and decisions about the work are made on the initiative. Refused (CONFLICT) when nothing is flagged or the cause has no resume: a plan that failed with needsHumanCause null (lifecycle.cta retry_plan, planFailureCause says why) is planned again with taiga_plan_again. Starts paid work.",
-		inputSchema: z.object({ itemId }),
+		inputSchema: z.object({ initiativeId }),
 		annotations: OPERATE
-	}, (params) => runTool(async () => outcome((await client.resumeInitiative(params.itemId)).data)));
+	}, (params) => runTool(async () => outcome((await client.resumeInitiative(params.initiativeId)).data)));
 }
 function registerPlanVerdicts(server, client) {
 	server.registerTool("taiga_approve_plan", {
@@ -3763,173 +4265,234 @@ function registerPlanVerdicts(server, client) {
 	}, (params) => runTool(async () => outcome((await client.rejectPlan(params.planId, { comment: params.comment })).data)));
 }
 //#endregion
-//#region src/tools/builds.ts
-/** What a list row needs to say for the model to pick a run to read in full. */
-const BUILD_SUMMARY_FIELDS = [
+//#region src/tools/maintenance.ts
+/**
+* Maintaining (docs.tai.ga, Operate): what the sweeps found in a product's
+* repository and where it stands against the organization's own policies,
+* and the two things a person does with a finding, Ignore and Fix. Sweeps run
+* themselves and nothing is marked fixed by hand: a finding resolves when the
+* next sweep no longer detects it, so there is no tool for either.
+*/
+/** A finding as a list row: enough to decide whether to open, fix or ignore it. */
+const FINDING_ROW_FIELDS = [
 	"id",
-	"runNumber",
-	"productId",
+	"kind",
+	"severity",
+	"tier",
+	"status",
+	"title",
+	"ecosystem",
+	"packageName",
+	"currentVersion",
+	"recommendedVersion",
+	"advisoryId",
+	"location",
+	"sourcePaths",
+	"productRepositoryId",
+	"ownership",
+	"remediableBy",
+	"controls",
 	"backlogItemId",
-	"targetTitle",
-	"planId",
+	"detectedAt",
+	"ignoreReason",
+	"ignoreExpiresAt"
+];
+/** A sweep as the record of when the product was last checked, and whether that check held. */
+const SWEEP_FIELDS = [
+	"id",
+	"trigger",
 	"status",
-	"failedReason",
-	"runtime",
-	"repositoryFullName",
-	"branch",
-	"baseBranch",
-	"completedSteps",
-	"totalSteps",
-	"prNumber",
-	"prUrl",
-	"prState",
-	"prDraft",
-	"prMerged",
-	"actions",
+	"scanners",
+	"findingsCount",
+	"newFindingsCount",
+	"error",
 	"createdAt",
-	"startedAt",
 	"completedAt"
 ];
-/** What a run says about itself after a stop or a resume: its state and what can be done next. */
-const RUN_OUTCOME_FIELDS = [
+/** A policy violation in a list: what it is, how bad, and what is being done about it. */
+const VIOLATION_FIELDS = [
 	"id",
-	"runNumber",
-	"backlogItemId",
+	"controlId",
+	"policyType",
+	"severity",
 	"status",
-	"failedReason",
-	"completedSteps",
-	"totalSteps",
-	"prUrl",
-	"actions"
-];
-/**
-* Where a run that ended without finishing stopped, from its steps and its
-* hardening result: a failed run with every step completed reads as nothing
-* failed, and retry_from_failed_step then reads as a mistake, when the agent
-* stalled in the hardening pass after the steps and the retry continues it.
-* Null for a run still going or that finished.
-*/
-function stoppedIn(run, steps) {
-	if (run.prMerged === true || run.status !== "failed" && run.status !== "stopped") return null;
-	if (!steps.some((step) => step.status !== "planned")) return "before the first step started, while setting up the run (cloning, preparing the workspace)";
-	const open = steps.find((step) => step.status !== "completed" && step.status !== "skipped");
-	if (open) return open.status === "planned" ? `before step ${String(open.stepOrder)}, ${String(open.title)}, started (the ones before it completed)` : `step ${String(open.stepOrder)}, ${String(open.title)} (${String(open.status)})`;
-	if (run.hardeningResult == null) return "after the last step, in hardening: the security scanners and their fixes the agent runs before the pull request is ready. A retry continues from there; the steps stay.";
-	return "after the steps and hardening, at the pull request";
-}
-/** How many products the org-wide list names; past this a row keeps its productId only. */
-const NAMED_PRODUCTS = 100;
-const buildId = idInput("build run", "taiga_list_builds gives it");
-/** A step without its instructions: what it is, how it stands and what it changed. */
-const STEP_SUMMARY_FIELDS = [
-	"stepOrder",
 	"title",
-	"status",
-	"currentPhase",
-	"commitSha",
-	"filesChanged",
-	"verification",
-	"error",
-	"errorClassification",
-	"startedAt",
-	"completedAt"
+	"summary",
+	"work",
+	"unconfirmedSince",
+	"verifyRequestedAt",
+	"assessedAt"
 ];
-/** Past this many characters a step's headline is cut; the full read has the rest. */
-const HEADLINE_LIMIT = 600;
-/**
-* The first paragraph of a step's summary: the agent writes its result
-* there (what changed, which checks passed), and the detail after it.
-*/
-function summaryHeadline(summary) {
-	if (typeof summary !== "string" || !summary.trim()) return null;
-	const first = summary.trim().split(/\n\s*\n/, 1)[0].trim();
-	return first.length > HEADLINE_LIMIT ? `${first.slice(0, HEADLINE_LIMIT).trimEnd()}...` : first;
-}
 /**
-* The runs of every product the key can see, each row naming its product.
-* The route carries product ids only; one products read names them, and a
-* failure of that read leaves the rows unnamed rather than failing the list.
-*/
-async function activityRows(client, opts) {
-	const [runs, products] = await Promise.all([client.listBuildRunActivity(opts), client.listProducts({ limit: NAMED_PRODUCTS }).catch((error) => {
-		if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
-		throw error;
-	})]);
-	const nameById = /* @__PURE__ */ new Map();
-	for (const product of products?.data ?? []) nameById.set(product.id, {
-		name: product.name,
-		slug: product.slug
-	});
-	const rows = pickFields(runs.data, BUILD_SUMMARY_FIELDS).map((row) => {
-		const product = nameById.get(String(row.productId));
-		return product ? {
-			...row,
-			product
-		} : row;
-	});
-	const note = !rows.some((row) => !("product" in row)) ? null : !products ? "The products could not be read, so rows carry productId only; taiga_get_product names one." : products.nextCursor !== null ? `Only the first ${NAMED_PRODUCTS} products could be named; a row without product carries productId only.` : "A row without product belongs to a product the key cannot list (deleted since, or not visible to it); it carries productId only.";
+* How bad a product's policy standing is, as counts: the controls something is
+* recorded against, the open violations by severity, the resolved ones. The
+* API's standing carries the lists only; this tool and the product context
+* both count them here.
+*/
+function standingSummary(standing) {
+	const controls = Array.isArray(standing.controls) ? standing.controls : [];
+	const violations = Array.isArray(standing.divergences) ? standing.divergences : [];
+	const resolved = Array.isArray(standing.resolvedDivergences) ? standing.resolvedDivergences.length : 0;
+	const listed = controls.filter((c) => Number(c["divergenceCount"] ?? 0) > 0 || Number(c["findingCount"] ?? 0) > 0);
+	const bySeverity = {};
+	for (const violation of violations) {
+		const severity = String(violation["severity"] ?? "unknown");
+		bySeverity[severity] = (bySeverity[severity] ?? 0) + 1;
+	}
 	return {
-		...page(rows, runs.nextCursor),
-		...note ? { note } : {}
+		controls: listed.length,
+		violations: violations.length,
+		bySeverity,
+		resolvedViolations: resolved
 	};
 }
-function registerBuildTools(server, client) {
+const findingId = idInput("finding", "taiga_list_findings gives it");
+function registerMaintenanceTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
-	server.registerTool("taiga_list_builds", {
-		title: "List build runs",
-		description: "List the coding agent's runs, newest first: status, branch, pull request, step progress and the actions a person may take on each. A run is the record of an attempt: work is carried on from its initiative (resume and retry_from_failed_step are taiga_resume_backlog_item; start_over is in the web only for now) and stopped by moving the initiative out of Build; a maintenance run, which has no initiative, is retried from its finding. With productId, the runs of that product, optionally of one backlog item; without it, the runs of every product the key can see, each row naming its product, and active: true narrows to the runs executing right now. Use this to see what Taiga already built or is building, then read one run with taiga_get_build. A run of a deleted initiative keeps its title.",
+	server.registerTool("taiga_get_maintenance", {
+		title: "Get a product's maintenance standing",
+		description: "Where a product's repository stands: open findings by severity and kind, the most pressing ones, and the latest sweeps, so you can tell when the product was last checked and whether that check succeeded. A quiet list from a sweep that last ran long ago, or that failed, is not an all-clear; a product never swept says so. Sweeps run on their own after a push and periodically; nothing here starts one. This is the overview of the scanners alone; taiga_list_findings lists each finding to act on, and taiga_get_policy_standing judges the product against the policies (scanner findings and the documents).",
+		inputSchema: z.object({ productId }),
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		const [summary, sweeps] = await Promise.all([client.getMaintenanceSummary(params.productId), client.listMaintenanceSweeps(params.productId, { limit: 3 })]);
+		const latest = pickFields(sweeps.data, SWEEP_FIELDS);
+		const { lastRun: _lastRun, lastRuns: _lastRuns, ...standing } = summary.data;
+		return toolResult({
+			...standing,
+			latestSweeps: latest,
+			...latest.length === 0 ? { note: "This product has never been swept: no result is not an all-clear." } : {}
+		});
+	}));
+	server.registerTool("taiga_list_findings", {
+		title: "List maintenance findings",
+		description: "List what the sweeps found in a product's repository: vulnerable or outdated dependencies, committed secrets, insecure code (sast) and infrastructure misconfigurations (iac_misconfig). Each row carries its severity and its priority tier (act_now: known exploited; urgent: likely and serious; elevated: one of the two; routine), where it is, who can fix it (remediableBy: coding_agent, or upstream_only for a submodule or a dependency with no fixed version), the policy controls it breaches, and the initiative already fixing it (initiativeId). Omit status for the findings that need action; work from the top tier down. Read one in full with taiga_get_finding. taiga_get_maintenance has the counts and when the last sweep ran, which says whether an empty list can be trusted.",
 		inputSchema: z.object({
-			productId: productId.optional(),
-			backlogItemId: idInput("backlog item", "taiga_list_backlog_items (query finds one by title) gives it").optional().describe("Only this backlog item's runs -- get from taiga_list_backlog_items; needs productId"),
-			active: z.boolean().optional().describe("Only runs the agent is executing now (cloning through reviewing; a queued pending run is not yet executing and is left out); for the org-wide list"),
+			productId,
+			status: z.enum(MAINTENANCE_FINDING_STATUSES).optional().describe("Only findings in this status; omit for the ones needing action"),
+			severity: z.enum(MAINTENANCE_FINDING_SEVERITIES).optional().describe("Only this severity"),
+			kind: z.enum(MAINTENANCE_FINDING_KINDS).optional().describe("Only this kind of finding"),
 			...pagination
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		if (!params.productId && params.backlogItemId) return toolError("VALIDATION_ERROR", "backlogItemId narrows the runs of one product: pass its productId as well (the item carries it).");
-		if (params.productId && params.active) return toolError("VALIDATION_ERROR", "active narrows the org-wide list only: omit productId, or read the product's runs and judge each by its status.");
-		if (params.productId) {
-			const result = await client.listBuildRuns(params.productId, params);
-			return toolResult(page(pickFields(result.data, BUILD_SUMMARY_FIELDS), result.nextCursor));
-		}
-		return toolResult(await activityRows(client, params));
+		const { productId: id, ...filters } = params;
+		const result = await client.listFindings(id, filters);
+		return toolResult({
+			...page(pickFields(result.data, FINDING_ROW_FIELDS), result.nextCursor),
+			...typeof result.totalCount === "number" ? { totalCount: result.totalCount } : {}
+		});
+	}));
+	server.registerTool("taiga_get_finding", {
+		title: "Get a maintenance finding",
+		description: "Read one finding in full: what it is, how likely it is to be exploited (EPSS, the known-exploited list), the advisory and the fixed version, the place in the code, the policy controls it breaches, why it is ranked where it is, its history (reintroduced, previously resolved) and the remediation under way. A secret's value is never stored; the finding names the rule and the location only.",
+		inputSchema: z.object({ findingId }),
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => {
+		const { runId, ...finding } = (await client.getFinding(params.findingId)).data;
+		return toolResult(runId === void 0 ? finding : {
+			sweepId: runId,
+			...finding
+		});
 	}));
-	server.registerTool("taiga_get_build", {
-		title: "Get build run",
-		description: "Get one run with its steps: the run (status, pull request, hardening, metrics) and each step's title, status, commit, files changed, checks, any error and headline, the first paragraph of what the agent reported. Pass full: true for each step's complete instructions and report, several thousand tokens on a long run. Use this to pick up where the coding agent stopped, or to understand the pull request it opened. A run that failed or was stopped says where (stoppedIn: a step, or the hardening pass after them) and when it last made progress (lastProgressAt). Its actions name what the initiative accepts for it: resume and retry_from_failed_step (which continues from the first unfinished part) are taiga_resume_backlog_item, start_over is in the web only for now; to stop it, move the initiative out of Build. A maintenance run has no initiative and is retried from its finding.",
+	server.registerTool("taiga_get_policy_standing", {
+		title: "Get a product's policy standing",
+		description: "Where a product stands against the organization's own published policies: the controls it violates, each with its violations (critical and high only, each citing the policy's sentence and the document passage that contradicts it), what is being done about each (an initiative raised, a fix in progress, awaiting verification), and when the documents were derived and assessed, led by a summary of the counts. A control is breached when open scanner findings map to it, diverged when the assessment of the product documents found them contradicting it (a control can be both; state names the stronger, breached). A violation's work is the initiative raised for it; live: false means that initiative is done or canceled without the violation going away, so it needs a person or a new fix. A control breached by scanner findings counts them by tier (findingsByTier): a breach of routine findings only, such as secrets in test fixtures, is not an urgent one. A control with no violation is not listed, and it is not \"passing\" either: there is no such state. Pass full: true for every violation's evidence and the resolved ones. Fix a control with taiga_fix_policy_violation.",
 		inputSchema: z.object({
-			buildId,
-			full: z.boolean().optional().describe("Carry each step's complete instructions and report (default false: a summary)")
+			productId,
+			full: z.boolean().optional().describe("Carry each violation's evidence, the policy excerpt and the resolved violations (default false)")
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const [run, steps] = await Promise.all([client.getBuildRun(params.buildId), client.listBuildRunSteps(params.buildId)]);
-		const runRow = run.data;
-		const rows = steps.data;
-		const where = stoppedIn(runRow, rows);
-		const stop = where ? { stoppedIn: where } : {};
+		const standing = (await client.getPolicyStanding(params.productId)).data;
+		const controls = Array.isArray(standing.controls) ? standing.controls : [];
+		const violations = Array.isArray(standing.divergences) ? standing.divergences : [];
+		const listed = controls.filter((c) => Number(c.divergenceCount ?? 0) > 0 || Number(c.findingCount ?? 0) > 0);
+		const summary = standingSummary(standing);
 		if (params.full) return toolResult({
-			...runRow,
-			...stop,
-			steps: steps.data
+			summary,
+			...standing
 		});
 		return toolResult({
-			...runRow,
-			...stop,
-			steps: pickFields(rows, STEP_SUMMARY_FIELDS).map((step, index) => ({
-				...step,
-				headline: summaryHeadline(rows[index].summary)
-			}))
+			summary,
+			productId: standing.productId,
+			hasPolicies: standing.hasPolicies,
+			assessment: standing.assessment,
+			documents: standing.documents,
+			controls: pickFields(listed, [
+				"controlId",
+				"policyType",
+				"text",
+				"state",
+				"divergenceCount",
+				"findingCount",
+				"findingsByTier",
+				"plannedCount"
+			]),
+			violations: pickFields(violations, VIOLATION_FIELDS)
 		});
 	}));
 	if (!client.hasCapability("products:write")) return;
-	server.registerTool("taiga_stop_build", {
-		title: "Stop a build run",
-		description: "The emergency brake: stop a run the coding agent is executing when its initiative cannot be moved. The way to stop work is on the initiative: move it out of Build (taiga_move_backlog_item), which stops the plan or run in flight. Use this only for a run whose initiative does not offer that (it is finished, canceled or gone) yet the run is still going. The agent halts, its branch and any draft pull request stay. Only a run whose actions include stop; the API refuses the rest with CONFLICT. Ask the person before calling this: it interrupts work in progress.",
-		inputSchema: z.object({ buildId }),
+	server.registerTool("taiga_ignore_finding", {
+		title: "Ignore or reopen a finding",
+		description: "Ignore a finding that does not apply or whose risk is accepted, with the reason (false_positive, not_reachable, accepted_risk, wont_fix), an optional note and an optional expiry after which it resurfaces if it still exists; or reopen an ignored one (ignored: false). Ignored findings are kept and reviewable. There is no \"mark fixed\": a finding resolves when the next sweep no longer detects it. For a secret that is only in history, rotate the credential outside Taiga, then ignore it with a reason. Ignoring hides a shared signal and can record the team's acceptance of a risk, which is the person's decision: ask the person first.",
+		inputSchema: z.object({
+			findingId,
+			ignored: z.boolean().describe("true ignores the finding, false reopens it"),
+			reason: z.enum(MAINTENANCE_IGNORE_REASONS).optional().describe("Why it is ignored; required when ignoring"),
+			note: z.string().trim().max(280).optional().describe("A short justification, kept for audit"),
+			expiresAt: z.string().datetime({ offset: true }).optional().describe("When the ignore lapses and the finding resurfaces if it still exists (ISO 8601, in the future)")
+		}),
+		annotations: OPERATE
+	}, (params) => runTool(async () => {
+		if (params.ignored && params.reason === void 0) return toolError("VALIDATION_ERROR", "Say why the finding is ignored (reason).");
+		const body = params.ignored ? {
+			status: "ignored",
+			ignoreReason: params.reason,
+			...params.note !== void 0 ? { ignoreNote: params.note } : {},
+			...params.expiresAt !== void 0 ? { ignoreExpiresAt: params.expiresAt } : {}
+		} : { status: "open" };
+		const finding = (await client.updateFinding(params.findingId, body)).data;
+		return toolResult(pickFields([finding], [...FINDING_ROW_FIELDS, "ignoreNote"])[0]);
+	}));
+	server.registerTool("taiga_fix_finding", {
+		title: "Fix a finding",
+		description: "Ask for a finding's fix: Taiga raises an initiative and adds it to the end of the product's queue, where the line plans it in turn; whether the build then waits for a person is the initiative's review gate, as for any initiative. The fix is a normal run that ends in a pull request you review and merge. With wholeGroup: true it fixes the finding's whole group in one initiative, as the page does: for a dependency, every open advisory on that package at that installed version in one version bump; for code or infrastructure, every location the same rule flagged. Absent for a secret only in history, anything in a submodule, and a dependency with no fixed version (remediableBy says upstream_only); the API refuses those. Starts paid work.",
+		inputSchema: z.object({
+			productId,
+			findingId,
+			wholeGroup: z.boolean().optional().describe("Fix every finding in this finding's group (its package and version, or its rule) together")
+		}),
+		annotations: OPERATE
+	}, (params) => runTool(async () => {
+		if (!params.wholeGroup) {
+			const fixed = (await client.remediateFinding(params.productId, params.findingId)).data;
+			return toolResult({
+				backlogItemId: fixed.backlogItemId,
+				finding: fixed.finding ? pickFields([fixed.finding], FINDING_ROW_FIELDS)[0] : null
+			});
+		}
+		const finding = (await client.getFinding(params.findingId)).data;
+		if (finding.productId !== params.productId) return toolError("NOT_FOUND", "No such finding in this product.");
+		return toolResult((await client.remediatePackage(params.productId, {
+			ecosystem: String(finding.ecosystem),
+			packageName: String(finding.packageName),
+			currentVersion: typeof finding.currentVersion === "string" ? finding.currentVersion : null,
+			productRepositoryId: typeof finding.productRepositoryId === "string" ? finding.productRepositoryId : null
+		})).data);
+	}));
+	server.registerTool("taiga_fix_policy_violation", {
+		title: "Fix policy violations",
+		description: "Ask for the fix of a product's policy violations: name a control to cover every violation recorded against it that has no initiative yet, or a single violation (violationId) when the control has more than one. Taiga raises one initiative and adds it to the end of the product's queue, exactly as a finding fix does. The violation stays listed while the work is under way: only the next assessment can record that the documents no longer show it. Starts paid work.",
+		inputSchema: z.object({
+			productId,
+			controlId: z.string().min(1).max(40).optional().describe("The control's identifier, e.g. SEC-3.4"),
+			violationId: idInput("violation", "taiga_get_policy_standing gives it").optional()
+		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		return toolResult(pickFields([(await client.stopBuildRun(params.buildId)).data], RUN_OUTCOME_FIELDS)[0]);
+		if (params.controlId === void 0 === (params.violationId === void 0)) return toolError("VALIDATION_ERROR", "Name either a control (controlId) or one violation (violationId), not both or neither.");
+		return toolResult((params.controlId ? await client.remediatePolicyControl(params.productId, params.controlId) : await client.remediatePolicyViolation(params.productId, params.violationId)).data);
 	}));
 }
 //#endregion
@@ -3953,9 +4516,9 @@ const REPOSITORY_SUMMARY_FIELDS = [
 	"effectiveBranch",
 	"isManaged"
 ];
-/** How many of the latest runs to carry; taiga_list_builds pages the rest. */
+/** How many of the latest runs to carry; taiga_list_runs pages the rest. */
 const BUILDS_IN_CONTEXT = 10;
-/** A run as the bundle carries it: enough to say what was built and where; taiga_get_build has the rest. */
+/** A run as the bundle carries it: enough to say what was built and where; taiga_get_run has the rest. */
 const CONTEXT_BUILD_FIELDS = [
 	"id",
 	"runNumber",
@@ -3965,6 +4528,8 @@ const CONTEXT_BUILD_FIELDS = [
 	"failedReason",
 	"completedSteps",
 	"totalSteps",
+	"baseBranch",
+	"prNumber",
 	"prUrl",
 	"prState",
 	"prMerged",
@@ -4022,7 +4587,7 @@ const DOCUMENT_DEPTHS = [
 const BACKLOG_PAGE_LIMIT = 10;
 /**
 * Open items the bundle carries, the newest of those read; past this it says truncated and
-* taiga_list_backlog_items pages the rest. Keeps a product with hundreds of
+* taiga_list_initiatives pages the rest. Keeps a product with hundreds of
 * open initiatives inside the tool result the document budget is sized for.
 */
 const BACKLOG_IN_CONTEXT = 50;
@@ -4032,7 +4597,10 @@ const PARTS = {
 	policies: "tenant:documents:read",
 	backlog: "backlog:read",
 	repositories: "products:read",
-	builds: "products:read"
+	builds: "products:read",
+	attention: "products:read",
+	maintenance: "products:read",
+	standing: "products:read"
 };
 /** What the API said when a part failed, in the words the bundle reports. */
 function unavailableReason(reason) {
@@ -4188,9 +4756,9 @@ async function backlogPart(client, productId) {
 	const rows = [...open.values()].sort((a, b) => String(a.id) < String(b.id) ? -1 : String(a.id) > String(b.id) ? 1 : 0);
 	if (rows.length > BACKLOG_IN_CONTEXT) truncated = true;
 	return {
-		items: itemRows(rows.slice(-50), BACKLOG_SUMMARY_FIELDS),
+		items: situatedRows(rows.slice(-50)),
 		truncated,
-		...pageCapped ? { note: "More than 1000 open items in one status: only the oldest of them were read, so the newest may be missing here; taiga_list_backlog_items pages the rest." } : {}
+		...pageCapped ? { note: "More than 1000 open items in one status: only the oldest of them were read, so the newest may be missing here; taiga_list_initiatives pages the rest." } : {}
 	};
 }
 /**
@@ -4206,7 +4774,53 @@ async function repositoriesPart(client, productId) {
 }
 async function buildsPart(client, productId) {
 	const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data;
-	return pickFields(rows, CONTEXT_BUILD_FIELDS);
+	return pickFields(rows, CONTEXT_BUILD_FIELDS).map(readableRun);
+}
+/**
+* What waits on a person for this product, counted by kind (PRO-2800): the
+* reviewing agent called four tools to answer "how does it stand"; the
+* counts say whether taiga_list_action_required is worth a call.
+*/
+async function attentionPart(client, productId) {
+	const result = await client.listInbox({
+		productId,
+		limit: 100,
+		withTotal: true
+	});
+	const now = Date.now();
+	const rows = result.data;
+	const byKind = {};
+	for (const row of rows) byKind[String(row["kind"])] = (byKind[String(row["kind"])] ?? 0) + 1;
+	const snoozed = rows.filter((row) => row["status"] === "snoozed" && typeof row["snoozedUntil"] === "string" && Date.parse(row["snoozedUntil"]) > now).length;
+	return {
+		open: typeof result.totalCount === "number" ? result.totalCount : rows.length,
+		byKind,
+		...snoozed > 0 ? { snoozed } : {},
+		...result.nextCursor ? { note: "byKind and snoozed count the first 100; taiga_list_action_required pages the rest." } : {}
+	};
+}
+/** The latest sweep and what it left open, as counts; taiga_list_findings lists them. */
+async function maintenancePart(client, productId) {
+	const summary = (await client.getMaintenanceSummary(productId)).data;
+	const last = summary["lastRun"];
+	return {
+		openFindings: summary["openFindings"],
+		bySeverity: summary["severityCounts"],
+		lastSweep: last ? {
+			status: last["status"],
+			completedAt: last["completedAt"]
+		} : null,
+		...last ? {} : { note: "Never swept: no findings is not an all-clear." }
+	};
+}
+/** Where the product stands against the policies, as counts; taiga_get_policy_standing has each violation. */
+async function standingPart(client, productId) {
+	const summary = standingSummary((await client.getPolicyStanding(productId)).data);
+	return {
+		openViolations: summary.violations,
+		bySeverity: summary.bySeverity,
+		controlsViolated: summary.controls
+	};
 }
 async function productContext(client, product, options) {
 	const productId = product.id;
@@ -4218,16 +4832,18 @@ async function productContext(client, product, options) {
 		policies: () => policiesPart(client),
 		backlog: () => backlogPart(client, productId),
 		repositories: () => repositoriesPart(client, productId),
-		builds: () => buildsPart(client, productId)
+		builds: () => buildsPart(client, productId),
+		attention: () => attentionPart(client, productId),
+		maintenance: () => maintenancePart(client, productId),
+		standing: () => standingPart(client, productId)
 	};
 	const parts = Object.keys(fetchers).filter(granted);
-	const settled = await Promise.allSettled(parts.map((part) => fetchers[part]()));
-	const nextStep = setupNextStep(product);
+	const [settled, readiness] = await Promise.all([Promise.allSettled(parts.map((part) => fetchers[part]())), setupReadiness(client, product)]);
 	const bundle = { product: {
 		...pickFields([product], PRODUCT_SUMMARY_FIELDS)[0],
 		projectType: isImportedProduct(product) ? "brownfield" : "greenfield",
 		defaultOrigin: defaultOriginFor(product),
-		...nextStep ? { nextStep } : {}
+		...readiness ? { readiness } : {}
 	} };
 	const unavailable = {};
 	parts.forEach((part, index) => {
@@ -4240,15 +4856,15 @@ async function productContext(client, product, options) {
 		...bundle,
 		notGranted: notGranted.map((part) => `${part} (needs ${PARTS[part]})`),
 		unavailable,
-		readNext: "Read a policy with taiga_get_document (sections: the ids listed here, for only those), the specification's or architecture's sections or another product document with taiga_get_product_document, a backlog item with taiga_get_backlog_item (taiga_list_backlog_items pages a truncated backlog) and a run with taiga_get_build."
+		readNext: "Read a policy with taiga_get_document (sections: the ids listed here, for only those), the specification's or architecture's sections or another product document with taiga_get_product_document, an initiative with taiga_get_initiative (taiga_list_initiatives pages a truncated backlog) and a run with taiga_get_run."
 	};
-	let characters = JSON.stringify(result, null, 2).length;
+	let characters = JSON.stringify(inProductWords(result), null, 2).length;
 	for (let measured = -1; measured !== characters;) {
 		measured = characters;
-		characters = JSON.stringify({
+		characters = JSON.stringify(inProductWords({
 			...result,
 			characters: measured
-		}, null, 2).length;
+		}), null, 2).length;
 	}
 	return toolResult({
 		...result,
@@ -4259,7 +4875,7 @@ function registerContextTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
 	server.registerTool("taiga_get_product_context", {
 		title: "Get product context",
-		description: `Everything a coding session starts from, in one call: the product and which document timeline is its own, its factory with the instructions in full, the specification and architecture from that timeline, every published policy as its section ids, the open backlog items, the linked repositories and the latest runs. Name the product by ID, slug or the git remote URL of the checkout. A part the API refused or failed is named under unavailable with what it said; a part the key cannot read is named under notGranted; neither is shown as empty. The two documents come as their outline by default: each section id with its size, to read with taiga_get_product_document naming the sections. Before writing code, documents: budget brings as many whole sections as fit, about ${DOCUMENT_BUDGET / 1e3}k characters each, naming the ones left out; full brings them whole, tens of thousands of tokens on a large product and more than some clients accept. characters says how large the result is. Call this first, then read what you need.`,
+		description: `Where a product stands and everything a coding session starts from, in one call. Name the product by ID, slug or the git remote URL of a checkout. It carries: the product (and, while in setup, readiness: what it still needs and the next move); its factory with the instructions in full; the specification and architecture as outlines (section ids and sizes); every published policy as its section ids; the open initiatives (not the done or canceled ones: taiga_list_initiatives has those); the linked repositories; the latest runs, each with its outcome in a sentence; attention, what waits on a person for it, counted by kind; maintenance, open findings by severity and the last sweep; standing, open policy violations by severity. A part the API refused or failed is named under unavailable; a part the key cannot read under notGranted; neither is shown as empty. Before writing code, documents: budget brings the whole sections that fit, about ${DOCUMENT_BUDGET / 1e3}k characters each, and full brings them whole (tens of thousands of tokens on a large product). Unlike taiga_get_product, which is the product record and its settings alone. Call this first, then read what you need.`,
 		inputSchema: z.object({
 			productId: productId.optional(),
 			slug: slug.optional(),
@@ -4316,12 +4932,12 @@ function registerAutonomyTools(server, client) {
 		title: "Set whether an initiative's pull request merges on its own",
 		description: "An initiative's own switch for merging on its own: true lets its pull request merge itself once the repository's own rules pass (required checks, reviews, a code reviewer you made Taiga wait for); false makes it wait for a person; null follows the product's default. The final word within what the organization and factories allow: where either has turned autonomous merge off, true changes nothing. Taiga merges through your rules, never around them.",
 		inputSchema: z.object({
-			itemId: idInput("backlog item", "taiga_list_backlog_items (query finds one by title) gives it"),
+			initiativeId: idInput("initiative", "taiga_list_initiatives (query finds one by title) gives it"),
 			autoMerge: z.boolean().nullable().describe("true merges on its own, false waits for a person, null follows the product")
 		}),
 		annotations: OPERATE_SETTING
 	}, (params) => runTool(async () => {
-		const item = (await client.updateBacklogItem(params.itemId, { autoMerge: params.autoMerge })).data;
+		const item = (await client.updateBacklogItem(params.initiativeId, { autoMerge: params.autoMerge })).data;
 		return toolResult(pickFields([item], [
 			"id",
 			"title",
@@ -4334,11 +4950,9 @@ function registerAutonomyTools(server, client) {
 //#endregion
 //#region src/tools/inbox.ts
 /**
-* Action Required (docs.tai.ga, Deliver): where work comes back to a person.
-* Things to review (a plan, a pull request, findings, policy violations) and
-* things to set up that only a person can (a secret, an account, a cloud
-* permission). The inbox is the team's: resolving an item clears it for
-* everybody, so these tools say what they clear.
+* 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",
@@ -4353,10 +4967,48 @@ const ITEM_FIELDS = [
 	"status",
 	"blocking",
 	"snoozedUntil",
-	"metadata",
 	"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;
+}
+/** 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) {
+	const { snoozedUntil, resolvedAt, ...rest } = pickFields([row], ITEM_FIELDS)[0];
+	const metadata = row["metadata"] ?? {};
+	const created = typeof row["createdAt"] === "string" ? Date.parse(row["createdAt"]) : NaN;
+	return {
+		...rest,
+		...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"] } : {}
+	};
+}
+/** 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) ?? {
+			productId: key,
+			product: row["productName"] ?? key,
+			open: 0,
+			byKind: {}
+		};
+		entry.open += 1;
+		entry.byKind[String(row["kind"])] = (entry.byKind[String(row["kind"])] ?? 0) + 1;
+		byProduct.set(key, entry);
+	}
+	return [...byProduct.values()].sort((a, b) => b.open - a.open);
+}
+/** Pages read for the summary; past this it says it counted only those. */
+const SUMMARY_PAGE = 100;
 const SETUP_TASK_FIELDS = [
 	"id",
 	"productId",
@@ -4377,38 +5029,94 @@ const SETUP_TASK_FIELDS = [
 function totalOf(result) {
 	return typeof result.totalCount === "number" ? { totalCount: result.totalCount } : {};
 }
+/**
+* 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.
+* The oldest row stays, and names the others under alsoFiledAs, so the
+* duplicates read as one thing to set with several records, not several things.
+*/
+function sameKeyOnce(rows) {
+	const first = /* @__PURE__ */ new Map();
+	const out = [];
+	const isOpen = (row) => row["inboxItemStatus"] !== "done" && row["inboxItemStatus"] !== "dismissed";
+	for (const row of rows) {
+		if (typeof row["key"] !== "string" || !row["key"]) {
+			out.push(row);
+			continue;
+		}
+		const key = `${String(row["productId"])}:${row["key"]}`;
+		const kept = first.get(key);
+		if (!kept) {
+			const copy = { ...row };
+			first.set(key, copy);
+			out.push(copy);
+			continue;
+		}
+		const also = kept["alsoFiledAs"] ?? [];
+		const record = (from) => ({
+			id: from["id"],
+			category: from["category"],
+			title: from["title"],
+			inboxItemStatus: from["inboxItemStatus"]
+		});
+		if (!isOpen(kept) && isOpen(row)) {
+			const { alsoFiledAs: _also, ...was } = kept;
+			for (const field of Object.keys(kept)) delete kept[field];
+			Object.assign(kept, row, { alsoFiledAs: [...also, record(was)] });
+		} else kept["alsoFiledAs"] = [...also, record(row)];
+	}
+	return out;
+}
 function registerInboxTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
 	server.registerTool("taiga_list_action_required", {
 		title: "List what needs a person",
-		description: "Read Action Required, where work comes back to a person: things to review (a plan, a set of initiatives, a document, a pull request, maintenance findings, new policy violations), each a decision an agent handed back rather than made, and things to set up that only a person can (a secret, an environment variable, an account, a package registry, a cloud permission). Across every product the key can open (each row names its product), or one product. category gate is the reviews, setup the setup items; resolved: true reads the archive of done and dismissed ones. The inbox is shared: it is the team's, not one person's. An item snoozed until later is left out until then, as the page leaves it out (snoozedHidden counts them). The first page says how many there are on every page (totalCount, snoozed ones included). taiga_list_setup_tasks has the setup tasks with what exactly to set.",
+		description: "Read Action Required, where work comes back to a person, shared by the team: things to review (a plan, a set of initiatives, a document decision, a pull request, maintenance findings, new policy violations) and things to set up that only a person can (a secret, an environment variable, an account, a package registry, a cloud permission). Across every product the key can open, or one product. The first page opens with summary: what is open, counted by product and kind, so \"what needs attention\" is one call, and totalCount. Each row says how many days it has waited (waitingDays) and, for a pull request review, the prUrl; an old item is still open, not stale. category gate is the reviews, setup the setup items; resolved: true reads the archive. An item snoozed until later is left out until then (snoozedHidden counts them). full: true adds each item's metadata. Unlike taiga_list_setup_tasks, which lists the setup items with exactly what to set and where.",
 		inputSchema: z.object({
 			productId: productId.optional(),
 			category: z.enum(["gate", "setup"]).optional().describe("gate: things to review; setup: things to set up"),
 			resolved: z.boolean().optional().describe("Read the resolved archive (done and dismissed) instead"),
+			full: z.boolean().optional().describe("Carry each item's metadata, such as a document decision's whole text (default false)"),
 			...pagination
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const { resolved, ...rest } = params;
-		const result = await client.listInbox({
+		const { resolved, full, ...rest } = params;
+		const query = {
 			...rest,
-			...resolved ? { resolved: true } : {},
-			...params.cursor === void 0 ? { withTotal: true } : {}
+			...resolved ? { resolved: true } : {}
+		};
+		const first = params.cursor === void 0;
+		const result = await client.listInbox({
+			...query,
+			...first ? { withTotal: true } : {}
+		});
+		const overview = !first || resolved ? null : !result.nextCursor ? result : await client.listInbox({
+			...query,
+			limit: SUMMARY_PAGE,
+			cursor: void 0
+		}).catch((error) => {
+			if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
+			throw error;
 		});
 		const now = Date.now();
+		const isDue = (row) => !(row["status"] === "snoozed" && typeof row["snoozedUntil"] === "string" && Date.parse(row["snoozedUntil"]) > now);
 		const rows = result.data;
-		const due = rows.filter((row) => !(row.status === "snoozed" && typeof row.snoozedUntil === "string" && Date.parse(row.snoozedUntil) > now));
+		const due = rows.filter(isDue);
 		const hidden = rows.length - due.length;
 		return toolResult({
-			...page(pickFields(due, ITEM_FIELDS), result.nextCursor),
+			...overview ? {
+				summary: summaryOf(overview.data.filter(isDue)),
+				...overview.nextCursor ? { summaryNote: `The summary counts the first ${SUMMARY_PAGE} items.` } : {}
+			} : {},
+			...page(due.map((row) => itemRow(row, now, full === true)), result.nextCursor),
 			...totalOf(result),
 			...hidden > 0 ? { snoozedHidden: hidden } : {}
 		});
 	}));
 	server.registerTool("taiga_list_setup_tasks", {
 		title: "List setup tasks",
-		description: "The setup tasks agents raised for work only a person can do, with what exactly to set and where: the name of an environment variable, secret or API key to create (key; never its value, which Taiga does not store or display), the provider page to do it on, and the phase that says when it blocks you (prereq: before the deploy, which fails without it; wiring: connecting generated values back to providers; followup: billing approvals, extra permissions and the like that can wait until after launch). A build does not wait for any of them. Across every product the key can open (each row names its product), or one. The tasks still to do, oldest first, the order they depend on each other; includeDone: true adds the done and dismissed ones. The first page says how many there are on every page (totalCount).",
+		description: "The setup tasks agents raised for work only a person can do, with what exactly to set and where: the name of an environment variable, secret or API key to create (key; never its value, which Taiga does not store or display), the provider page to do it on, and the phase that says when it blocks you (prereq: before the deploy, which fails without it; wiring: connecting generated values back to providers; followup: billing approvals, extra permissions and the like that can wait until after launch). A build does not wait for any of them. Across every product the key can open (each row names its product), or one. The tasks still to do, oldest first, the order they depend on each other; includeDone: true adds the done and dismissed ones. The first page says how many there are on every page (totalCount). One row per variable: a variable filed twice (as a secret and as an environment variable) lists the other records under alsoFiledAs, an open one first; within a page, and totalCount counts every record. Unlike taiga_list_action_required, whose setup items are the same work as rows to resolve, this says exactly what to set and where.",
 		inputSchema: z.object({
 			productId: productId.optional(),
 			includeDone: z.boolean().optional().describe("Also the tasks already done or dismissed (default false)"),
@@ -4423,7 +5131,7 @@ function registerInboxTools(server, client) {
 			...params.cursor === void 0 ? { withTotal: true } : {}
 		});
 		return toolResult({
-			...page(pickFields(result.data, SETUP_TASK_FIELDS), result.nextCursor),
+			...page(sameKeyOnce(pickFields(result.data, SETUP_TASK_FIELDS)), result.nextCursor),
 			...totalOf(result)
 		});
 	}));
@@ -4432,7 +5140,7 @@ function registerInboxTools(server, client) {
 		title: "Resolve or snooze an Action Required item",
 		description: "Clear an item from Action Required, for everybody: done means you did it, dismissed means it does not apply and is not going to, in_progress means someone has picked it up. Or snooze it until a time (an hour, tomorrow, a week; null wakes it). Nothing marks a setup task done for you: setting the variable or connecting the registry is the work, and marking it done is still a person's. Resolving a review item does not approve or merge anything; the plan or pull request is answered where it lives. One exception: marking the product documents review item done records, in your name, that every published document was reviewed, and setting it back to in_progress withdraws that; do it only when the person says they read them. Ask the person before clearing what they have not dealt with.",
 		inputSchema: z.object({
-			itemId: idInput("Action Required item", "taiga_list_action_required gives it"),
+			actionId: idInput("Action Required item", "taiga_list_action_required gives it"),
 			status: z.enum([
 				"in_progress",
 				"done",
@@ -4443,7 +5151,7 @@ function registerInboxTools(server, client) {
 		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.itemId, {
+		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]);
@@ -4633,219 +5341,6 @@ function registerKnowledgeTools(server, client) {
 	}));
 }
 //#endregion
-//#region src/tools/maintenance.ts
-/**
-* Maintaining (docs.tai.ga, Operate): what the sweeps found in a product's
-* repository and where it stands against the organization's own policies,
-* and the two things a person does with a finding, Ignore and Fix. Sweeps run
-* themselves and nothing is marked fixed by hand: a finding resolves when the
-* next sweep no longer detects it, so there is no tool for either.
-*/
-/** A finding as a list row: enough to decide whether to open, fix or ignore it. */
-const FINDING_ROW_FIELDS = [
-	"id",
-	"kind",
-	"severity",
-	"tier",
-	"status",
-	"title",
-	"ecosystem",
-	"packageName",
-	"currentVersion",
-	"recommendedVersion",
-	"advisoryId",
-	"location",
-	"sourcePaths",
-	"productRepositoryId",
-	"ownership",
-	"remediableBy",
-	"controls",
-	"backlogItemId",
-	"detectedAt",
-	"ignoreReason",
-	"ignoreExpiresAt"
-];
-/** A sweep as the record of when the product was last checked, and whether that check held. */
-const SWEEP_FIELDS = [
-	"id",
-	"trigger",
-	"status",
-	"scanners",
-	"findingsCount",
-	"newFindingsCount",
-	"error",
-	"createdAt",
-	"completedAt"
-];
-/** A policy violation in a list: what it is, how bad, and what is being done about it. */
-const VIOLATION_FIELDS = [
-	"id",
-	"controlId",
-	"policyType",
-	"severity",
-	"status",
-	"title",
-	"summary",
-	"work",
-	"unconfirmedSince",
-	"verifyRequestedAt",
-	"assessedAt"
-];
-const findingId = idInput("finding", "taiga_list_findings gives it");
-function registerMaintenanceTools(server, client) {
-	if (!client.hasCapability("products:read")) return;
-	server.registerTool("taiga_get_maintenance", {
-		title: "Get a product's maintenance standing",
-		description: "Where a product's repository stands: open findings by severity and kind, the most pressing ones, and the latest sweeps, so you can tell when the product was last checked and whether that check succeeded. A quiet list from a sweep that last ran long ago, or that failed, is not an all-clear; a product never swept says so. Sweeps run on their own after a push and periodically; nothing here starts one. Read the findings with taiga_list_findings and the policy standing with taiga_get_policy_standing.",
-		inputSchema: z.object({ productId }),
-		annotations: READ_ONLY
-	}, (params) => runTool(async () => {
-		const [summary, sweeps] = await Promise.all([client.getMaintenanceSummary(params.productId), client.listMaintenanceSweeps(params.productId, { limit: 3 })]);
-		const latest = pickFields(sweeps.data, SWEEP_FIELDS);
-		const { lastRun: _lastRun, lastRuns: _lastRuns, ...standing } = summary.data;
-		return toolResult({
-			...standing,
-			latestSweeps: latest,
-			...latest.length === 0 ? { note: "This product has never been swept: no result is not an all-clear." } : {}
-		});
-	}));
-	server.registerTool("taiga_list_findings", {
-		title: "List maintenance findings",
-		description: "List what the sweeps found in a product's repository: vulnerable or outdated dependencies, committed secrets, insecure code (sast) and infrastructure misconfigurations (iac_misconfig). Each row carries its severity and its priority tier (act_now: known exploited; urgent: likely and serious; elevated: one of the two; routine), where it is, who can fix it (remediableBy: coding_agent, or upstream_only for a submodule or a dependency with no fixed version), the policy controls it breaches, and the initiative already fixing it (backlogItemId). Omit status for the findings that need action; work from the top tier down. Read one in full with taiga_get_finding.",
-		inputSchema: z.object({
-			productId,
-			status: z.enum(MAINTENANCE_FINDING_STATUSES).optional().describe("Only findings in this status; omit for the ones needing action"),
-			severity: z.enum(MAINTENANCE_FINDING_SEVERITIES).optional().describe("Only this severity"),
-			kind: z.enum(MAINTENANCE_FINDING_KINDS).optional().describe("Only this kind of finding"),
-			...pagination
-		}),
-		annotations: READ_ONLY
-	}, (params) => runTool(async () => {
-		const { productId: id, ...filters } = params;
-		const result = await client.listFindings(id, filters);
-		return toolResult({
-			...page(pickFields(result.data, FINDING_ROW_FIELDS), result.nextCursor),
-			...typeof result.totalCount === "number" ? { totalCount: result.totalCount } : {}
-		});
-	}));
-	server.registerTool("taiga_get_finding", {
-		title: "Get a maintenance finding",
-		description: "Read one finding in full: what it is, how likely it is to be exploited (EPSS, the known-exploited list), the advisory and the fixed version, the place in the code, the policy controls it breaches, why it is ranked where it is, its history (reintroduced, previously resolved) and the remediation under way. A secret's value is never stored; the finding names the rule and the location only.",
-		inputSchema: z.object({ findingId }),
-		annotations: READ_ONLY
-	}, (params) => runTool(async () => toolResult((await client.getFinding(params.findingId)).data)));
-	server.registerTool("taiga_get_policy_standing", {
-		title: "Get a product's policy standing",
-		description: "Where a product stands against the organization's own published policies: the controls it violates, each with its violations (critical and high only, each citing the policy's sentence and the document passage that contradicts it), what is being done about each (an initiative raised, a fix in progress, awaiting verification), and when the documents were derived and assessed, led by a summary of the counts. A control breached by scanner findings counts them by tier (findingsByTier): a breach of routine findings only, such as secrets in test fixtures, is not an urgent one. A control with no violation is not listed, and it is not \"passing\" either: there is no such state. Pass full: true for every violation's evidence and the resolved ones. Fix a control with taiga_fix_policy_violation.",
-		inputSchema: z.object({
-			productId,
-			full: z.boolean().optional().describe("Carry each violation's evidence, the policy excerpt and the resolved violations (default false)")
-		}),
-		annotations: READ_ONLY
-	}, (params) => runTool(async () => {
-		const standing = (await client.getPolicyStanding(params.productId)).data;
-		const controls = Array.isArray(standing.controls) ? standing.controls : [];
-		const violations = Array.isArray(standing.divergences) ? standing.divergences : [];
-		const resolved = Array.isArray(standing.resolvedDivergences) ? standing.resolvedDivergences.length : 0;
-		const listed = controls.filter((c) => Number(c.divergenceCount ?? 0) > 0 || Number(c.findingCount ?? 0) > 0);
-		const bySeverity = {};
-		for (const violation of violations) {
-			const severity = String(violation.severity ?? "unknown");
-			bySeverity[severity] = (bySeverity[severity] ?? 0) + 1;
-		}
-		const summary = {
-			controls: listed.length,
-			violations: violations.length,
-			bySeverity,
-			resolvedViolations: resolved
-		};
-		if (params.full) return toolResult({
-			summary,
-			...standing
-		});
-		return toolResult({
-			summary,
-			productId: standing.productId,
-			hasPolicies: standing.hasPolicies,
-			assessment: standing.assessment,
-			documents: standing.documents,
-			controls: pickFields(listed, [
-				"controlId",
-				"policyType",
-				"text",
-				"state",
-				"divergenceCount",
-				"findingCount",
-				"findingsByTier",
-				"plannedCount"
-			]),
-			violations: pickFields(violations, VIOLATION_FIELDS)
-		});
-	}));
-	if (!client.hasCapability("products:write")) return;
-	server.registerTool("taiga_ignore_finding", {
-		title: "Ignore or reopen a finding",
-		description: "Ignore a finding that does not apply or whose risk is accepted, with the reason (false_positive, not_reachable, accepted_risk, wont_fix), an optional note and an optional expiry after which it resurfaces if it still exists; or reopen an ignored one (ignored: false). Ignored findings are kept and reviewable. There is no \"mark fixed\": a finding resolves when the next sweep no longer detects it. For a secret that is only in history, rotate the credential outside Taiga, then ignore it with a reason. Ignoring hides a shared signal and can record the team's acceptance of a risk, which is the person's decision: ask the person first.",
-		inputSchema: z.object({
-			findingId,
-			ignored: z.boolean().describe("true ignores the finding, false reopens it"),
-			reason: z.enum(MAINTENANCE_IGNORE_REASONS).optional().describe("Why it is ignored; required when ignoring"),
-			note: z.string().trim().max(280).optional().describe("A short justification, kept for audit"),
-			expiresAt: z.string().datetime({ offset: true }).optional().describe("When the ignore lapses and the finding resurfaces if it still exists (ISO 8601, in the future)")
-		}),
-		annotations: OPERATE
-	}, (params) => runTool(async () => {
-		if (params.ignored && params.reason === void 0) return toolError("VALIDATION_ERROR", "Say why the finding is ignored (reason).");
-		const body = params.ignored ? {
-			status: "ignored",
-			ignoreReason: params.reason,
-			...params.note !== void 0 ? { ignoreNote: params.note } : {},
-			...params.expiresAt !== void 0 ? { ignoreExpiresAt: params.expiresAt } : {}
-		} : { status: "open" };
-		const finding = (await client.updateFinding(params.findingId, body)).data;
-		return toolResult(pickFields([finding], [...FINDING_ROW_FIELDS, "ignoreNote"])[0]);
-	}));
-	server.registerTool("taiga_fix_finding", {
-		title: "Fix a finding",
-		description: "Ask for a finding's fix: Taiga raises an initiative and adds it to the end of the product's queue, where the line plans it in turn; whether the build then waits for a person is the initiative's review gate, as for any initiative. The fix is a normal run that ends in a pull request you review and merge. With wholeGroup: true it fixes the finding's whole group in one initiative, as the page does: for a dependency, every open advisory on that package at that installed version in one version bump; for code or infrastructure, every location the same rule flagged. Absent for a secret only in history, anything in a submodule, and a dependency with no fixed version (remediableBy says upstream_only); the API refuses those. Starts paid work.",
-		inputSchema: z.object({
-			productId,
-			findingId,
-			wholeGroup: z.boolean().optional().describe("Fix every finding in this finding's group (its package and version, or its rule) together")
-		}),
-		annotations: OPERATE
-	}, (params) => runTool(async () => {
-		if (!params.wholeGroup) {
-			const fixed = (await client.remediateFinding(params.productId, params.findingId)).data;
-			return toolResult({
-				backlogItemId: fixed.backlogItemId,
-				finding: fixed.finding ? pickFields([fixed.finding], FINDING_ROW_FIELDS)[0] : null
-			});
-		}
-		const finding = (await client.getFinding(params.findingId)).data;
-		if (finding.productId !== params.productId) return toolError("NOT_FOUND", "No such finding in this product.");
-		return toolResult((await client.remediatePackage(params.productId, {
-			ecosystem: String(finding.ecosystem),
-			packageName: String(finding.packageName),
-			currentVersion: typeof finding.currentVersion === "string" ? finding.currentVersion : null,
-			productRepositoryId: typeof finding.productRepositoryId === "string" ? finding.productRepositoryId : null
-		})).data);
-	}));
-	server.registerTool("taiga_fix_policy_violation", {
-		title: "Fix policy violations",
-		description: "Ask for the fix of a product's policy violations: name a control to cover every violation recorded against it that has no initiative yet, or a single violation (violationId) when the control has more than one. Taiga raises one initiative and adds it to the end of the product's queue, exactly as a finding fix does. The violation stays listed while the work is under way: only the next assessment can record that the documents no longer show it. Starts paid work.",
-		inputSchema: z.object({
-			productId,
-			controlId: z.string().min(1).max(40).optional().describe("The control's identifier, e.g. SEC-3.4"),
-			violationId: idInput("violation", "taiga_get_policy_standing gives it").optional()
-		}),
-		annotations: OPERATE
-	}, (params) => runTool(async () => {
-		if (params.controlId === void 0 === (params.violationId === void 0)) return toolError("VALIDATION_ERROR", "Name either a control (controlId) or one violation (violationId), not both or neither.");
-		return toolResult((params.controlId ? await client.remediatePolicyControl(params.productId, params.controlId) : await client.remediatePolicyViolation(params.productId, params.violationId)).data);
-	}));
-}
-//#endregion
 //#region src/tools/observe.ts
 /**
 * What runs where and how it is doing (docs.tai.ga, Deliver: Deployments;
@@ -5102,7 +5597,7 @@ function registerProductDocumentWrites(server, client) {
 	}, (params) => runTool(() => updateSection(productScope(params.productId, params.type), params.type, params.sectionId, params.content)));
 	server.registerTool("taiga_publish_product_document", {
 		title: "Publish a product document draft",
-		description: "Publish a product document's draft as its new version, the one agents work from. Documents generated from it are not rewritten: each is marked outdated, and is regenerated when someone chooses to (taiga_regenerate_product_document, or taiga_generate_product_documents for every outdated and missing one). Ask the person before publishing.",
+		description: "Publish a product document's draft as its new version, the one agents work from. Documents generated from it are not rewritten: each is marked outdated, and is regenerated when someone chooses to (taiga_regenerate_product_document, or taiga_generate_product_documents for every outdated and missing one).",
 		inputSchema: z.object({
 			productId,
 			type: documentType
@@ -19782,18 +20277,18 @@ function registerPrompts(server, client) {
 			"",
 			"Before writing code: follow the factory instructions; read the policy sections that touch what you are",
 			"about to change with taiga_get_document (security, data, SDLC, architecture at least); read the backlog",
-			"item you are implementing with taiga_get_backlog_item. Parts listed under notGranted or unavailable",
+			"item you are implementing with taiga_get_initiative. Parts listed under notGranted or unavailable",
 			"could not be read; say so rather than assuming they are empty.",
 			"",
 			fence("json", (await productContext(client, resolved.product, { documents: "full" })).content[0]?.text ?? "{}")
 		].join("\n"));
 	});
-	if (client.hasCapability("backlog:read") && client.hasCapability("products:read")) server.registerPrompt("taiga_implement_backlog_item", {
-		title: "Implement a backlog item",
-		description: "Implement one initiative: its description and acceptance criteria, the architecture of the product from its own timeline, the factory's instructions and the policy sections to check against. taiga_list_backlog_items gives the item ID.",
-		argsSchema: z.object({ itemId: idInput("backlog item", "taiga_list_backlog_items (query finds one by title) gives it") })
+	if (client.hasCapability("backlog:read") && client.hasCapability("products:read")) server.registerPrompt("taiga_implement_initiative", {
+		title: "Implement an initiative",
+		description: "Implement one initiative: its description and acceptance criteria, the architecture of the product from its own timeline, the factory's instructions and the policy sections to check against. taiga_list_initiatives gives the item ID.",
+		argsSchema: z.object({ initiativeId: idInput("initiative", "taiga_list_initiatives (query finds one by title) gives it") })
 	}, async (args) => {
-		const item = (await served$1(client.getBacklogItem(args.itemId), "No backlog item with that ID the key can see; taiga_list_backlog_items shows what exists")).data;
+		const item = (await served$1(client.getBacklogItem(args.initiativeId), "No initiative with that ID the key can see; taiga_list_initiatives shows what exists")).data;
 		const productId = String(item.productId);
 		const product = (await served$1(client.getProduct(productId), "The product of that item is not visible to the key")).data;
 		const origin = defaultOriginFor(product, "architecture");
@@ -19892,7 +20387,8 @@ const GITHUB_REPOSITORY_FIELDS = [
 	"archived",
 	"defaultBranch",
 	"description",
-	"language"
+	"language",
+	"linked"
 ];
 const repositoryId = idInput("repository link", "taiga_list_product_repositories gives it; a GitHub repository id is not one");
 /** Round-robin over lists: the first of each, then the second of each, and so on. */
@@ -19934,7 +20430,7 @@ function registerRepositoryTools(server, client) {
 	}
 	if (client.hasCapability("vcs:read")) server.registerTool("taiga_list_linkable_repositories", {
 		title: "Find a repository to link",
-		description: "The repositories the organization's GitHub connection can reach, to link one to a product (taiga_link_repository takes its id). Searches by name with query. Name the GitHub account (account: its login, the owner in owner/repo, or installationId) to read only its repositories; without one it reads every connected account and takes rows from each in turn, so one account cannot fill the page. No connection means GitHub is not connected yet: that is done once, in the web, by someone who can install the app.",
+		description: "The repositories the organization's GitHub connection can reach, to link one to a product (taiga_link_repository takes its id). Searches by name with query. Name the GitHub account (account: its login, the owner in owner/repo, or installationId) to read only its repositories; without one it reads every connected account and takes rows from each in turn, so one account cannot fill the page. linked: true means a product already links it (taiga_resolve_product says which). No connection means GitHub is not connected yet: that is done once, in the web, by someone who can install the app.",
 		inputSchema: z.object({
 			query: z.string().trim().min(1).max(256).optional().describe("Part of the repository name"),
 			account: z.string().trim().min(1).max(140).optional().describe("The GitHub account login (the owner in owner/repo), case-insensitive"),
@@ -20138,13 +20634,13 @@ function registerResources(server, client) {
 			return read(uri, productId, type, defaultOriginFor(product, type));
 		});
 	}
-	if (client.hasCapability("backlog:read")) server.registerResource("backlog-item", new ResourceTemplate("taiga://backlog/{itemId}", { list: void 0 }), {
-		title: "Backlog item",
-		description: "An initiative in full: description, acceptance criteria, technical context. taiga_list_backlog_items gives the item ID.",
+	if (client.hasCapability("backlog:read")) server.registerResource("backlog-item", new ResourceTemplate("taiga://initiatives/{initiativeId}", { list: void 0 }), {
+		title: "Initiative",
+		description: "An initiative in full: description, acceptance criteria, technical context. taiga_list_initiatives gives the item ID.",
 		mimeType: "application/json"
 	}, async (uri, variables) => {
-		const itemId = requireId("Backlog item ID", String(variables["itemId"]));
-		const item = (await served(client.getBacklogItem(itemId), "No backlog item with that ID the key can see; taiga_list_backlog_items shows what exists")).data;
+		const initiativeId = requireId("Initiative ID", String(variables["initiativeId"]));
+		const item = (await served(client.getBacklogItem(initiativeId), "No initiative with that ID the key can see; taiga_list_initiatives shows what exists")).data;
 		return { contents: [{
 			uri: uri.href,
 			mimeType: "application/json",
@@ -20188,33 +20684,17 @@ const buildScope = {
 const deploymentNotes = z.string().trim().min(1).max(DEPLOYMENT_NOTES_MAX_LENGTH).describe("When a half is off: a sentence on how it is done today, which Taiga designs and plans against");
 /** How a missing required document comes to exist, said with a documents_incomplete refusal. */
 const MISSING_DOCUMENTS_HOW = "An imported product gets them from its import (taiga_start_import); a product started from scratch gets the specification from the Discovery conversation in the web and the rest from taiga_generate_product_documents. A draft is published with taiga_publish_product_document.";
-/** A product row the model can act on, saying how it started as the other product tools say it. */
+/** A product row the model can act on: how it started, and while in setup what it still needs. */
 async function productRow(client, product) {
 	const { settings: _settings, ...rest } = pickFields([product], PRODUCT_FIELDS)[0];
-	const nextStep = setupNextStep(await withDiscoveryStep(client, product));
+	const readiness = await setupReadiness(client, product);
 	return {
 		...rest,
 		projectType: isImportedProduct(product) ? "brownfield" : "greenfield",
-		...nextStep ? { nextStep } : {}
+		...readiness ? { readiness } : {}
 	};
 }
 /**
-* The product with its discoveryStep. The API derives it on reads only, not
-* on the answer to a write (products.ts), and a draft started from scratch
-* needs it to say what comes next; an imported one reads its import status
-* instead. Best effort: a failed read leaves the product without a nextStep
-* rather than failing the write that already happened.
-*/
-async function withDiscoveryStep(client, product) {
-	if (product.status !== "draft" || "discoveryStep" in product || isImportedProduct(product)) return product;
-	try {
-		return (await client.getProduct(String(product.id))).data;
-	} catch (error) {
-		if (error instanceof TaigaApiError || isNetworkFailure(error)) return product;
-		throw error;
-	}
-}
-/**
 * A half turned off with nothing said about how it is done today. Allowed (the
 * web asks for the sentence but does not insist), so a warning rather than a
 * refusal: plans then design against a gap.
@@ -20259,7 +20739,7 @@ function registerSetupTools(server, client) {
 		}, (params) => runTool(async () => toolResult((await client.previewProductMove(params.productId, params.factoryId)).data)));
 		server.registerTool("taiga_move_product", {
 			title: "Move a product to another factory",
-			description: "Move a product to another factory. Access follows the factory, so this changes who can reach the product (taiga_preview_product_move says who); the product's own knowledge files are re-filed onto the new factory, and factory knowledge and instructions stay with the factory that owns them. Refused (CONFLICT) while a plan or build is in flight: stopLine: true stops the line first and then moves, which interrupts that work.",
+			description: "Move a product to another factory. Access follows the factory, so this changes who can reach the product (taiga_preview_product_move says who); the product's own knowledge files are re-filed onto the new factory, and factory knowledge and instructions stay with the factory that owns them. Refused (WORK_IN_FLIGHT) while a plan or build is in flight. Then ask the person: stopLine: true stops the line first and then moves, which interrupts that work.",
 			inputSchema: z.object({
 				productId,
 				factoryId: factoryId.describe("The factory to move it to"),
@@ -20267,10 +20747,16 @@ function registerSetupTools(server, client) {
 			}),
 			annotations: OPERATE
 		}, (params) => runTool(async () => {
-			const moved = await client.moveProduct(params.productId, {
-				factoryId: params.factoryId,
-				...params.stopLine ? { stopLine: true } : {}
-			});
+			let moved;
+			try {
+				moved = await client.moveProduct(params.productId, {
+					factoryId: params.factoryId,
+					...params.stopLine ? { stopLine: true } : {}
+				});
+			} catch (error) {
+				if (error instanceof TaigaApiError && error.code === "WORK_IN_FLIGHT") return toolError("WORK_IN_FLIGHT", `${withStop((error.apiMessage ?? "Work is in flight on this product").split(/(?<=[.!?])\s/)[0])} Moving it now means stopping the line, which interrupts that work: ask the person, and pass stopLine: true only if they say so.`, error.details);
+				throw error;
+			}
 			return toolResult({
 				product: await productRow(client, moved.data),
 				changed: moved.changed,
@@ -20564,7 +21050,9 @@ function judgeItem(until, gate) {
 /** The initiative as a wait reports it: where it is, whose turn, its latest run and its criteria. */
 function itemReport(item) {
 	const run = latestBuildOf(item);
+	const situation = situationOf(item);
 	return {
+		...situation ? { situation } : {},
 		...pickFields([item], [
 			"id",
 			"title",
@@ -20611,6 +21099,8 @@ const RUN_REPORT_FIELDS = [
 	"prState",
 	"prDraft",
 	"prMerged",
+	"prNumber",
+	"baseBranch",
 	"actions"
 ];
 const runSignature = (run) => JSON.stringify([
@@ -20631,11 +21121,11 @@ function judgeBuild(until) {
 	};
 }
 function registerWaitTools(server, client, options) {
-	if (client.hasCapability("backlog:read")) server.registerTool("taiga_wait_for_backlog_item", {
+	if (client.hasCapability("backlog:read")) server.registerTool("taiga_wait_for_initiative", {
 		title: "Wait for an initiative",
 		description: "Wait until an initiative reaches a point, instead of reading it again and again: changed (anything about where it is or its latest run), planned (its plan landed), your_turn (it waits on a person: a plan to review, a pull request, a flag), pr_open (a pull request open now; a merged or closed one does not count), run_settled (its latest run stopped moving) or done (finished; a canceled one stops the wait). Returns as soon as that holds (reached: true), early when it cannot hold without a person (a flag, a failed plan, a plan waiting for its verdict, a pull request waiting for a review, a cancelled initiative, or a landed plan whose review gate cannot be read; stoppedBecause says which), or at the timeout with reached: false: call again to keep waiting. Conditions are states, not events: an initiative whose latest run is already settled answers run_settled at once; item is null when not even the first read answered in time. Planning takes minutes and a build up to an hour.",
 		inputSchema: z.object({
-			itemId: idInput("backlog item", "taiga_list_backlog_items (query finds one by title) gives it"),
+			initiativeId: idInput("initiative", "taiga_list_initiatives (query finds one by title) gives it"),
 			until: z.enum(ITEM_CONDITIONS).describe("What to wait for"),
 			timeoutSeconds
 		}),
@@ -20643,7 +21133,7 @@ function registerWaitTools(server, client, options) {
 	}, (params, ctx) => runTool(async () => {
 		const gate = { product: void 0 };
 		const read = async (signal) => {
-			const item = (await client.getBacklogItem(params.itemId, signal)).data;
+			const item = (await client.getBacklogItem(params.initiativeId, signal)).data;
 			if (gate.product === void 0 && typeof item.autoBuild !== "boolean") gate.product = client.hasCapability("products:read") ? await client.getProduct(String(item.productId), signal).then((p) => {
 				const value = p.data.autoBuild;
 				return typeof value === "boolean" ? value : true;
@@ -20664,17 +21154,17 @@ function registerWaitTools(server, client, options) {
 			item: now ? itemReport(now) : null
 		});
 	}));
-	if (client.hasCapability("products:read")) server.registerTool("taiga_wait_for_build", {
+	if (client.hasCapability("products:read")) server.registerTool("taiga_wait_for_run", {
 		title: "Wait for a run",
 		description: "Wait until a coding agent's run reaches a point: changed (status, steps or pull request), step_done (one more step finished), pr_open (open now, not merged or closed) or settled (it stopped moving: in review, completed, failed, stopped). Returns as soon as that holds (reached: true), early when the run settled without it (stoppedBecause; changed waits on, since a person resuming the run is a change), or at the timeout with reached: false: call again to keep waiting. Conditions are states: a run already settled answers settled at once; run is null when not even the first read answered in time.",
 		inputSchema: z.object({
-			buildId: idInput("build run", "taiga_list_builds gives it"),
+			runId: idInput("run", "taiga_list_runs gives it"),
 			until: z.enum(BUILD_CONDITIONS).describe("What to wait for"),
 			timeoutSeconds
 		}),
 		annotations: READ_ONLY
 	}, (params, ctx) => runTool(async () => {
-		const { now, ...outcome } = await waitFor(async (signal) => (await client.getBuildRun(params.buildId, signal)).data, judgeBuild(params.until), (params.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1e3, options, {
+		const { now, ...outcome } = await waitFor(async (signal) => (await client.getBuildRun(params.runId, signal)).data, judgeBuild(params.until), (params.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1e3, options, {
 			progressToken: ctx.mcpReq._meta?.progressToken,
 			notify: ctx.mcpReq.notify,
 			signal: ctx.mcpReq.signal
@@ -20682,7 +21172,7 @@ function registerWaitTools(server, client, options) {
 		return toolResult({
 			until: params.until,
 			...outcome,
-			run: now ? pickFields([now], RUN_REPORT_FIELDS)[0] : null
+			run: now ? readableRun(pickFields([now], RUN_REPORT_FIELDS)[0]) : null
 		});
 	}));
 	if (client.hasCapability("products:read")) server.registerTool("taiga_wait_for_job", {
@@ -20725,7 +21215,8 @@ function withStrictInputs(server) {
 		const withHint = (args, ctx) => notFoundHints.run(notFoundHint(name, args), () => handler(args, ctx));
 		const described = {
 			...config,
-			description: `${writeNotice(name, config.annotations)}${config.description ?? ""}`
+			description: `${writeNotice(name, config.annotations)}${config.description ?? ""}`,
+			...ALWAYS_LOAD.has(name) ? { _meta: { "anthropic/alwaysLoad": true } } : {}
 		};
 		return register(name, schema ? {
 			...described,
@@ -20735,6 +21226,19 @@ function withStrictInputs(server) {
 	return server;
 }
 /**
+* The entry points, loaded with their descriptions at session start
+* (PRO-2800). Claude Code defers every other MCP tool behind tool search and
+* shows the model only its name until it searches, so an agent meeting Taiga
+* sees these three in full: where a product stands, which products there
+* are, and what waits on a person. Three, because each one loaded upfront
+* costs every session its description.
+*/
+const ALWAYS_LOAD = /* @__PURE__ */ new Set([
+	"taiga_get_product_context",
+	"taiga_list_products",
+	"taiga_list_action_required"
+]);
+/**
 * What a tool's annotations say, in its description's first words (PRO-2778).
 * Annotations are for the client: Claude Code does not show them to the
 * model, so an agent read 79 tools without knowing which ones write. A tool
@@ -20771,136 +21275,40 @@ function registerAllTools(server, client, options = {}) {
 	registerResources(server, client);
 	registerPrompts(server, client);
 }
+//#endregion
+//#region src/tools/instructions.ts
+/**
+* What the server tells a client at connect time. Claude Code loads only the
+* tool NAMES and these instructions until the model searches for a tool, and
+* cuts each server's instructions at 2,048 characters (code.claude.com, MCP
+* tool search), so this is the whole introduction an agent gets: what Taiga
+* holds, when to search these tools, where to start, the words, when to ask,
+* and what only the web does. Everything else lives in the tool descriptions,
+* which load with the tool. The earlier instructions ran to about 8,000
+* characters, and everything past the first 2,000 never reached the model
+* (PRO-2800).
+*/
 const SERVER_INSTRUCTIONS = [
-	[
-		"You have access to Taiga, a policy-aware software development platform: the organization's",
-		"engineering knowledge base, its products, their backlog and what the coding agent has built.",
-		"",
-		"**Start here.** Call taiga_get_product_context first, naming the product by its git remote URL inside a",
-		"checkout (git remote get-url origin), else by slug or ID (taiga_list_products finds one by name with",
-		"query). It returns the product (and, while it is in setup, nextStep: what it waits for), its factory",
-		"instructions, the outline of its specification and architecture, every policy as its section ids, the",
-		"open initiatives, the repositories and the latest runs. Then read only what you need: sections by id with",
-		"taiga_get_document or taiga_get_product_document (sections: [] is any document's outline), an",
-		"initiative with taiga_get_backlog_item. Check Action Required (taiga_list_action_required) for what",
-		"waits on a person.",
-		"",
-		"**Before you write.** Tell the person what you are about to do and wait for their yes before a tool that",
-		"starts paid agent work (queueing, approving, resuming, requesting, importing, generating), interrupts it",
-		"(stopping, pausing) or changes what others read (publishing, resolving, settings, repositories). Such a",
-		"tool says so first in its description; a client that prompts on destructive tools does part of it.",
-		"",
-		"**Answers.** A refusal carries the API reason: say it as it is. NOT_FOUND names the tool that lists the",
-		"right IDs; an ID is a UUID, never a name. An empty result says why when it has a reason.",
-		"",
-		"**Words.** A backlog item is an initiative; a build is a run, the record of one attempt at it; Action",
-		"Required is the inbox; the line is the queue; a factory is the group that owns a set of products."
-	].join("\n"),
-	"",
-	"**Company documents** (taiga_list_documents / taiga_get_document):",
-	`The ${POLICY_TYPES.length} policies (${named(POLICY_TYPES)}) carry the security, data, SDLC, operations and`,
-	`architecture rules that apply to all code. The other documents (${named(OTHER_TENANT_DOCUMENT_TYPES)})`,
-	"carry the business goals, design and brand standards, tone of voice and standing instructions.",
-	"Read the relevant policy BEFORE writing code that touches security, data handling or infrastructure.",
-	"",
-	"**Factory instructions** (taiga_list_factory_documents / taiga_get_factory_document):",
-	"A factory's standing guidance: domain context (ubiquitous language, entities, business rules),",
-	"tech preferences (approved stack, patterns) and conventions. Read these to understand HOW this factory",
-	"builds software. A factory that has not written any yet has none; that is normal.",
-	"",
-	"**Product documents** (taiga_list_product_documents / taiga_get_product_document):",
-	`${Object.entries(PRODUCT_DOCUMENT_NAMES).map(([type, name]) => `${name} (${type})`).join(", ")}.`,
-	"A product has two timelines of these, and the list shows both:",
-	`- ${ORIGIN_MEANING.plan}`,
-	`- ${ORIGIN_MEANING.reality}`,
-	"An imported (brownfield) product has no generated discovery chain: its derived documents are on the",
-	"reality side, while the documents a person writes (Look & Feel, Product Instructions) are on the plan",
-	"side of every product. Omit origin on a read and the server picks the right side (the list reports the",
-	"product's own as defaultOrigin). To understand",
-	"what to build, read the plan where there is one; to understand the code you are changing, read reality",
-	"when it exists, the ground truth for architecture, data flow and threats as built.",
-	"",
-	"**Backlog and runs** (taiga_list_backlog_items / taiga_get_backlog_item / taiga_list_builds / taiga_get_build):",
-	"The product's initiatives with their acceptance criteria, and what Taiga's coding agent already built",
-	"for them: runs, steps, commits and pull requests. taiga_list_builds without a product lists the runs of",
-	"every product the key can see, and active: true the ones executing now.",
-	"",
-	"**Operating the line** works the way Taiga is meant to be used. New work is described, not written:",
-	"taiga_request_initiatives asks an agent, which reads the product and its repository, expands the request",
-	"into initiatives in the Backlog (or says why it added none: already covered, not work, out of scope, or a",
-	"policy that does not allow it) -- follow it with taiga_wait_for_job. The queue is the only way to start",
-	"work (taiga_queue_backlog_item): Taiga plans and builds one initiative at a time, in queue order, and starts",
-	"the next when the pull request merges. Whether a landed plan waits for a review is the review gate",
-	"(taiga_set_auto_build, or autoBuild on the queue); read it with taiga_get_plan and answer with",
-	"taiga_approve_plan or taiga_reject_plan. Decisions about the work are made on the initiative: stop work by",
-	"moving it out of Build (taiga_move_backlog_item), carry it on with taiga_resume_backlog_item, ask for a new",
-	"plan with taiga_plan_again; a run is the record of an attempt. taiga_pause_line pauses the whole line.",
-	"taiga_stop_build is the emergency brake for a run whose initiative cannot be moved. Queueing, approving,",
-	"resuming and requesting start paid agent work; stopping and pausing interrupt it. Tell the person what you",
-	"are about to start or stop and wait for their yes; a client that prompts on destructive tools does that",
-	"for you. A refusal (CONFLICT) carries the API reason: say it as it is.",
-	"",
-	"**Watching the line** (taiga_get_queue / taiga_wait_for_backlog_item / taiga_wait_for_build /",
-	"taiga_get_job / taiga_wait_for_job): the queue read says what the line is waiting on (a paused line, a plan",
-	"to review, a pull request to merge, a halt and what lifts it). Planning takes minutes and a build up to an",
-	"hour: wait with the wait tools rather than reading the same item again and again; each returns when the",
-	"point is reached, when only a person can move it on, or at its timeout (call again to keep waiting).",
-	"",
-	"**Action Required** (taiga_list_action_required / taiga_list_setup_tasks / taiga_resolve_action): where work",
-	"comes back to a person, shared by the team. Check it first. Resolving an item clears it for everybody; a",
-	"setup task is marked done only by the person who did the setup.",
-	"",
-	"**Maintaining** (taiga_get_maintenance / taiga_list_findings / taiga_get_finding / taiga_ignore_finding /",
-	"taiga_fix_finding / taiga_get_policy_standing / taiga_fix_policy_violation): what the sweeps found and where",
-	"the product stands against its own policies. Sweeps run on their own; check when the last one ran before",
-	"trusting a quiet list. A finding is ignored with a reason or fixed; a fix raises an initiative at the end of",
-	"the queue. Nothing is marked fixed by hand: the next sweep or assessment decides.",
-	"",
-	"**Deployments and monitoring** (taiga_get_deployments / taiga_get_delivery_metrics / taiga_get_monitoring /",
-	"taiga_define_environment / taiga_update_environment): what runs where, how delivery is going, and how each",
-	"environment is doing. Taiga observes deployments and never performs them. An environment needs only its App",
-	"URL for monitoring to start.",
-	"",
-	"**Knowledge** (taiga_list_knowledge / taiga_get_knowledge / taiga_add_knowledge / taiga_retry_knowledge /",
-	"taiga_delete_knowledge): reference material agents search when work calls for it, at the organization, a",
-	"factory or a product. A rule that applies every time belongs in instructions instead.",
-	"",
-	"**Setting a product up** (taiga_create_factory / taiga_create_product / taiga_update_product /",
-	"taiga_list_linkable_repositories / taiga_link_repository / taiga_start_import / taiga_finish_discovery /",
-	"taiga_reopen_discovery / taiga_move_product): a product starts from scratch (Discovery is a conversation,",
-	"held in the web) or by importing a repository, chosen when it is created. An import links the repository,",
-	"starts the import and runs by itself; finishing Discovery locks the documents and opens the rest of the",
-	"product. Linking a repository and creating or moving factories are for owners and admins. GitHub is",
-	"connected once, in the web; members and deleting stay there too.",
-	"",
-	"**Product documents and autonomy** (taiga_update_product_document / taiga_publish_product_document /",
-	"taiga_regenerate_product_document / taiga_generate_product_documents / taiga_stop_generating_documents /",
-	"taiga_mark_product_document_reviewed /",
-	"taiga_set_product_autonomy / taiga_set_auto_merge): edit a product document in its draft and publish it;",
-	"documents built from it are marked outdated and regenerated, not rewritten. Set whether plans wait for a",
-	"review and pull requests for a person to merge. Organization-wide settings, members, roles and connections",
-	"are administrators' work in the web.",
+	"Taiga is a policy-aware software delivery platform: an organization's policies and knowledge, its factories",
+	"and products, each product's initiatives (its backlog), the line that plans and builds them one at a time, the",
+	"coding agent's runs and pull requests, maintenance findings, and Action Required, where work waits on a person.",
+	"Search these tools whenever the person asks about a Taiga product, an initiative, a run or pull request, policy",
+	"or compliance, findings, deployments or monitoring, or setting a product up.",
 	"",
-	"**Sections.** Policies and instructions are maps of sections. Each section carries its text and two",
-	"provenance fields you can read past: `source` says where the text originally came from (template:",
-	"Taiga's standard text; overlay-<id>: a jurisdiction or industry overlay; cloud-preset:<providers>:",
-	"rendered for the organization's cloud providers; any other tag names the derivation that wrote the",
-	"text; a hand edit keeps the source it had) and",
-	"`priority: core` marks the sections every organization keeps. Neither changes what the section",
-	"requires of you.",
+	"**Start here.** taiga_get_product_context (the product by git remote URL, slug or ID) gives its state in one",
+	"call: what it still needs while in setup, its documents as outlines, policies as section ids, open initiatives,",
+	"recent runs with their outcome, and what waits on a person. Then read only what you need. Across products,",
+	"taiga_list_products and taiga_list_action_required.",
 	"",
-	"Without taiga_get_product_context, use taiga_list_factories and taiga_list_products, then read the",
-	"factory instructions, the product's specification and architecture, and the initiative you are working",
-	"on. A document read that finds nothing tells you what does exist and which tool reads or writes it.",
+	"**Words.** An initiative is a unit of work in the backlog; a run is one attempt by the coding agent to build it;",
+	"the line is the product's queue; a factory owns a set of products. IDs are UUIDs, never names; a NOT_FOUND names",
+	"the tool that lists the right ones. A refusal carries the reason: say it as it is.",
 	"",
-	"The same documents are resources (taiga://documents/{type}, taiga://products/{productId}/documents/{type},",
-	"taiga://factories/{factoryId}/instructions, taiga://backlog/{itemId}) for clients that attach them, and three",
-	"prompts open a session: taiga_start_session, taiga_implement_backlog_item, taiga_review_against_policies.",
+	"**Before you write.** A tool that writes says so first: \"Writes.\" or \"Acts on paid or shared work: ask the",
+	"person first.\" Ask before the second kind: it starts paid agent work, interrupts it, or changes what others see.",
 	"",
-	"When you notice a policy or factory instructions are outdated, fix the section with",
-	"taiga_update_document or taiga_update_factory_document. That saves a draft nobody follows yet;",
-	"publish it with taiga_publish_document or taiga_publish_factory_document only when the person asks.",
-	"This keeps the knowledge base accurate for everyone."
+	"**Only in the web:** connecting GitHub, members and roles, the Discovery conversation of a product started from",
+	"scratch, stamping checks, starting a run over, and deleting anything."
 ].join("\n");
 //#endregion
 //#region src/server.ts