@taiga-ai/mcp-server 0.11.0 → 0.12.0-rc.419

package/dist/index.js

@@ -114,7 +114,7 @@ var TaigaClient = class {
 		this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
 		this.apiKey = opts.apiKey;
 	}
-	async request(method, path, body, keep) {
+	async request(method, path, body, options = {}) {
 		const url = `${this.baseUrl}/v1${path}`;
 		const headers = {
 			Authorization: `Bearer ${this.apiKey}`,
@@ -124,17 +124,18 @@ var TaigaClient = class {
 		const response = await fetch(url, {
 			method,
 			headers,
-			body: body === void 0 ? null : JSON.stringify(body)
+			body: body === void 0 ? null : JSON.stringify(body),
+			...options.signal ? { signal: options.signal } : {}
 		});
 		if (!response.ok) {
 			const text = await response.text().catch(() => "");
 			throw new TaigaApiError(method, path, response.status, text);
 		}
 		const parsed = await response.json();
-		return keep ? parsed : withoutTenant(parsed);
+		return options.keepTenant ? parsed : withoutTenant(parsed);
 	}
 	async introspect() {
-		const result = await this.request("GET", "/auth/introspect", void 0, { tenantId: true });
+		const result = await this.request("GET", "/auth/introspect", void 0, { keepTenant: true });
 		this.introspection = result.data;
 		return result.data;
 	}
@@ -157,8 +158,8 @@ var TaigaClient = class {
 		const qs = params.toString();
 		return this.request("GET", `/products${qs ? `?${qs}` : ""}`);
 	}
-	async getProduct(id) {
-		return this.request("GET", `/products/${seg(id)}`);
+	async getProduct(id, signal) {
+		return this.request("GET", `/products/${seg(id)}`, void 0, { signal });
 	}
 	async listProductRepositories(productId) {
 		return this.request("GET", `/products/${seg(productId)}/repositories`);
@@ -225,8 +226,8 @@ var TaigaClient = class {
 		const qs = params.toString();
 		return this.request("GET", `/products/${seg(productId)}/backlog${qs ? `?${qs}` : ""}`);
 	}
-	async getBacklogItem(itemId) {
-		return this.request("GET", `/backlog/${seg(itemId)}`);
+	async getBacklogItem(itemId, signal) {
+		return this.request("GET", `/backlog/${seg(itemId)}`, void 0, { signal });
 	}
 	async createBacklogItem(productId, body) {
 		return this.request("POST", `/products/${seg(productId)}/backlog`, {
@@ -242,6 +243,14 @@ var TaigaClient = class {
 	async resumeInitiative(itemId) {
 		return this.request("POST", `/backlog/${seg(itemId)}/resume`);
 	}
+	/** The initiative's own review gate: true builds a landed plan at once, false stops for a person, null follows the product. */
+	async setAutoBuild(itemId, autoBuild) {
+		return this.request("PUT", `/backlog/${seg(itemId)}/auto-build`, { autoBuild });
+	}
+	/** The product's live queue, in order. */
+	async listQueue(productId) {
+		return this.request("GET", `/products/${seg(productId)}/queue`);
+	}
 	async getActivePlan(itemId) {
 		return this.request("GET", `/backlog/${seg(itemId)}/plans/active`);
 	}
@@ -268,8 +277,8 @@ var TaigaClient = class {
 		const qs = params.toString();
 		return this.request("GET", `/builds${qs ? `?${qs}` : ""}`);
 	}
-	async getBuildRun(id) {
-		return this.request("GET", `/builds/${seg(id)}`);
+	async getBuildRun(id, signal) {
+		return this.request("GET", `/builds/${seg(id)}`, void 0, { signal });
 	}
 	async stopBuildRun(id) {
 		return this.request("POST", `/builds/${seg(id)}/stop`);
@@ -662,7 +671,14 @@ const QUEUE_GLOBAL_BLOCKING_STATES = ["active"];
 */
 const QUEUE_POSITIONAL_BLOCKING_STATES = ["halted"];
 [...QUEUE_GLOBAL_BLOCKING_STATES, ...QUEUE_POSITIONAL_BLOCKING_STATES];
-Object.keys({
+/**
+* Why the queue stopped, as data.
+*
+* The `message` values for causes that already existed are VERBATIM the strings
+* the reconciler used to write, so this change is invisible to anyone reading
+* their queue.
+*/
+const HALT_CAUSES = {
 	/**
 	* A PERSON stopped the plan (PRO-1144). Distinct from `planning_failed`
 	* because the two leave the initiative in the same state and mean opposite
@@ -842,7 +858,52 @@ Object.keys({
 		clearedWhen: "never on its own; there is no principal left to run as",
 		exits: ["remove"]
 	}
-}).filter((c) => c !== "awaiting_plan_review" && c !== "armed_start_missing");
+};
+Object.keys(HALT_CAUSES).filter((c) => c !== "awaiting_plan_review" && c !== "armed_start_missing");
+function haltClearsItself(cause) {
+	return haltHasExit(cause, "auto");
+}
+/**
+* May a person lift this halt by hand?
+*
+* The complement of `haltClearsItself`, and NOT its negation: a cause can be
+* neither (queued_by_erased, whose only exit is removal, because there is no
+* principal left to run as no matter who presses what). Reads the registry so
+* the API's guard and the button's visibility come from one place instead of
+* two lists that drift.
+*/
+function canResumeHalt(cause) {
+	return haltHasExit(cause, "resume");
+}
+/**
+* The one place that indexes the registry by a cause, so the one place that has
+* to survive a cause it does not know.
+*
+* The type says that cannot happen, and server-side it cannot: the column has a
+* CHECK generated from this same list. But the BROWSER holds a bundle that can
+* be older than the API it is talking to, and `HALT_CAUSES[unknown].exits`
+* throws, which takes down the whole list rather than one badge. Fail closed:
+* an unknown cause offers no exits, so it neither auto-clears nor shows a
+* Resume button, and the row falls back to the prose the server sent.
+*/
+function haltHasExit(cause, exit) {
+	const spec = HALT_CAUSES[cause];
+	return spec ? spec.exits.includes(exit) : false;
+}
+/**
+* The sentence for a halt, rendered from its cause and params.
+*
+* ONE renderer, used both by the reconciler that stores the prose today and by
+* the read path that will compute it instead (PRO-1039 PR 3). A slot with no
+* matching param renders as the empty string rather than leaking `{name}` into
+* a user's queue.
+*/
+function renderHalt(h) {
+	const spec = HALT_CAUSES[h.cause];
+	if (!spec) return "";
+	const params = h.params;
+	return spec.message.replace(/\{(\w+)\}/g, (_m, key) => params[key] ?? "");
+}
 //#endregion
 //#region ../../packages/types/dist/build.js
 const BUILD_RUN_STATUSES = [
@@ -892,7 +953,17 @@ function runDisposition(status) {
 * = in_flight minus 'pending' (queued is not yet executing).
 */
 const BUILD_RUN_ACTIVE_STATUSES = BUILD_RUN_STATUSES.filter((s) => runDisposition(s) === "in_flight" && s !== "pending");
-BUILD_RUN_STATUSES.filter((s) => runDisposition(s) !== "in_flight");
+/**
+* Terminal-or-handoff statuses: the run will not move again WITHOUT a human
+* (dispatcher failure path preserves them; the FE realtime hook refreshes list
+* views when a phase_change carries one). 'needs_review' (the gate) is included
+* because the agent is done and the FE treats it like a terminal for
+* list-display purposes; 'failed'/'stopped' are re-armable but settled.
+* = everything that is not in_flight.
+* NB: buildRunStateMachine.terminalStatuses ({completed, closed}) is a
+* DIFFERENT, narrower concept: transitions a user command may never leave.
+*/
+const BUILD_RUN_TERMINAL_STATUSES = BUILD_RUN_STATUSES.filter((s) => runDisposition(s) !== "in_flight");
 [...BUILD_RUN_ACTIVE_STATUSES.filter((s) => s !== "reviewing")];
 [...TURN_EVENT_TRIGGERS];
 //#endregion
@@ -1073,6 +1144,29 @@ const ARTIFACT_SCALE_FRAME_NAMES = [
 ].map((token) => token.frame);
 [...ARTIFACT_CSS_VARIABLES, ...ARTIFACT_SCALE_FRAME_NAMES];
 new Set(ARTIFACT_CSS_VARIABLES.filter((name) => name !== "--radius"));
+//#endregion
+//#region ../../packages/types/dist/auto-build.js
+/**
+* Auto-build: the review-plans gate (PRO-1305).
+*
+* "Build as soon as the plan is ready?" is asked at two scopes -- the project's
+* default (`projects.auto_build`) and the initiative's own standing answer
+* (`backlog_items.auto_build`) -- in the same polarity as auto-merge, and this
+* is the one place they are combined, so the line, the queue's halt
+* derivation and the settings surfaces cannot drift apart on what "gated"
+* means.
+*/
+/**
+* Does this plan build without stopping for a person to read it?
+*
+* The initiative's own answer wins; the project's default answers when it has
+* none. Unlike auto-merge there is no ceiling above the project: reviewing a
+* plan is a working preference, not a permission, and PRO-1305 gives the
+* initiative the override in both directions for exactly that reason.
+*/
+function resolveAutoBuild(scopes) {
+	return scopes.initiative ?? scopes.product;
+}
 Object.freeze({
 	productKinds: true,
 	applicationOwnership: true
@@ -1481,6 +1575,56 @@ function instructionsText(sections) {
 	}
 	return parts.join("\n\n").trim() || null;
 }
+function cutTo(doc, sections, kept) {
+	const omittedSections = Object.keys(sections).filter((id) => !Object.hasOwn(kept, id)).map((id) => ({
+		id,
+		characters: sectionContent(sections, id)?.length ?? 0
+	}));
+	return {
+		doc: {
+			...doc,
+			data: {
+				...doc.data,
+				sections: kept
+			}
+		},
+		omittedSections
+	};
+}
+/**
+* The named sections of a section-shaped document, in the order the API
+* returns them (a jsonb column: shorter ids first, then by bytes, not the
+* order a person wrote them);
+* every other section is listed with its size so the reader knows what else
+* there is. Null when the document is not made of sections.
+*/
+function pickSections(doc, ids) {
+	const sections = isRecord(doc.data) ? sectionsOf(doc.data) : null;
+	if (!sections) return null;
+	return cutTo(doc, sections, Object.fromEntries(Object.entries(sections).filter(([id]) => ids.has(id))));
+}
+/**
+* As many whole sections as fit `budget` characters of text, the rest listed
+* with their sizes so the reader can ask for them by id. Whole, never cut: a
+* section's text is one argument, and half of it reads as all of it. Not "the
+* opening": the document's own order is not in the data (a jsonb column
+* hands back shorter ids first), so a section that does not fit is skipped
+* and a later, smaller one may still be carried. Null when the document is
+* not made of sections.
+*/
+function budgetSections(doc, budget) {
+	const sections = isRecord(doc.data) ? sectionsOf(doc.data) : null;
+	if (!sections) return null;
+	const kept = [];
+	let used = 0;
+	for (const id of Object.keys(sections)) {
+		const length = sectionContent(sections, id)?.length ?? 0;
+		if (used + length > budget) continue;
+		kept.push([id, sections[id]]);
+		used += length;
+	}
+	return cutTo(doc, sections, Object.fromEntries(kept));
+}
 //#endregion
 //#region src/tools/summarize.ts
 /**
@@ -1502,6 +1646,30 @@ function page(data, nextCursor) {
 		nextCursor: nextCursor ?? null
 	};
 }
+/**
+* How many of an initiative's acceptance criteria are met: one pair a row can
+* carry, so "done with two unmet" shows in a list without reading the item.
+* Null while it has none (an unplanned initiative).
+*/
+function criteriaCounts(item) {
+	const criteria = item.acceptanceCriteria;
+	if (!Array.isArray(criteria) || criteria.length === 0) return null;
+	return {
+		met: criteria.filter((c) => typeof c === "object" && c !== null && c.met === true).length,
+		total: criteria.length
+	};
+}
+/**
+* Initiative rows cut to `fields`, each with its criteria counts. A row that
+* does not carry `acceptanceCriteria` at all gets no count rather than a
+* null that would read as "has none".
+*/
+function itemRows(items, fields) {
+	return pickFields(items, fields).map((row, index) => "acceptanceCriteria" in items[index] ? {
+		...row,
+		criteria: criteriaCounts(items[index])
+	} : row);
+}
 //#endregion
 //#region src/tools/products.ts
 /** What a product row needs to say for the model to pick one and read it in full. */
@@ -1750,11 +1918,12 @@ function registerProductTools(server, client) {
 		}));
 		server.registerTool("taiga_get_product_document", {
 			title: "Get product document",
-			description: "Get the full content of one product document from one timeline. Read the plan to learn what to build: specification (requirements), architecture (design), threat_model (security risks), technology_decisions. Read reality, when the product has it, to learn what the code actually does before changing it. Omit origin for the product's own timeline. A read that finds nothing says which documents and timelines the product does have.",
+			description: "Get the full content of one product document from one timeline. Read the plan to learn what to build: specification (requirements), architecture (design), threat_model (security risks), technology_decisions. Read reality, when the product has it, to learn what the code actually does before changing it. Omit origin for the product's own timeline. A large document runs to tens of thousands of characters: name the sections you need (the ids taiga_get_product_context lists) and the read carries only those, listing the rest with their sizes. A read that finds nothing says which documents and timelines the product does have.",
 			inputSchema: {
 				productId,
 				type: z.enum(PRODUCT_DOCUMENT_TYPES).describe("Document type -- taiga_list_product_documents shows which ones the product has"),
-				origin: originInput
+				origin: originInput,
+				sections: z.array(z.string().min(1).max(200)).min(1).max(50).optional().describe("Only these sections, by id; omit for the whole document")
 			},
 			annotations: READ_ONLY
 		}, (params) => runTool(async () => {
@@ -1762,7 +1931,17 @@ function registerProductTools(server, client) {
 			if (!params.origin) product = (await client.getProduct(params.productId)).data;
 			const origin = params.origin ?? defaultOriginFor(product, params.type);
 			try {
-				return toolResult(stripProvenance((await client.getProductDocument(params.productId, params.type, origin)).data));
+				const doc = stripProvenance((await client.getProductDocument(params.productId, params.type, origin)).data);
+				if (!params.sections) return toolResult(doc);
+				const cut = pickSections(doc, new Set(params.sections));
+				if (!cut) return toolError("VALIDATION_FAILED", `The ${origin} ${params.type} is not made of sections; read it without sections.`);
+				const all = Object.keys(doc.data.sections);
+				const unknown = params.sections.filter((id) => !all.includes(id));
+				if (unknown.length > 0) return toolError("NOT_FOUND", `The ${origin} ${params.type} has no section ${unknown.join(", ")}; its sections are ${all.join(", ")}.`);
+				return toolResult({
+					...cut.doc,
+					omittedSections: cut.omittedSections
+				});
 			} catch (error) {
 				if (!(error instanceof TaigaApiError) || error.status !== 404) throw error;
 				product ??= (await client.getProduct(params.productId)).data;
@@ -1983,6 +2162,130 @@ function registerDocumentTools(server, client) {
 	}
 }
 //#endregion
+//#region src/tools/queue.ts
+/** How many entries the read names; past this an entry keeps its backlogItemId 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.";
+/**
+* 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
+* the advice cannot drift from what the API accepts; plan review is the one
+* cause a tool answers directly.
+*/
+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}`;
+	const known = cause;
+	if (canResumeHalt(known)) return `taiga_resume_backlog_item 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}.`;
+}
+/**
+* The entry the line waits on, by the queue's two kinds of blocker
+* (@taiga/types): an active entry holds every other one wherever it sits, so
+* it answers first; without one, the first halted entry holds the entries
+* behind it. -1 when neither is there.
+*/
+function blockingIndex(entries, stateOf) {
+	const active = entries.findIndex((entry) => stateOf(entry) === "active");
+	return active >= 0 ? active : entries.findIndex((entry) => stateOf(entry) === "halted");
+}
+/** The one sentence a person needs: what the line is doing, or what it is waiting on. */
+function waitingOn(rows) {
+	const at = blockingIndex(rows, (row) => row.entryState);
+	if (at < 0) return rows.length > 0 ? "Nothing in the queue is running; the first queued initiative starts when the line is free." : null;
+	const head = rows[at];
+	const name = typeof head.title === "string" ? `"${head.title}"` : `Initiative ${String(head.backlogItemId)}`;
+	if (head.entryState === "halted") {
+		const halt = head.halt;
+		const ahead = at > 0 ? " Entries ahead of it are not held by it." : "";
+		return `${name} halted the queue, holding the entries behind it: ${halt.reason} ${halt.nextStep}${ahead}`;
+	}
+	const lifecycle = head.lifecycle;
+	const held = "every other queued initiative waits until its pull request merges.";
+	if (!lifecycle) return `${name} is the active entry; ${held}`;
+	const pr = typeof head.prUrl === "string" ? ` (${head.prUrl})` : "";
+	if (lifecycle.cta === "start_build") return `${name} has its plan and waits for the Build slot; ${held}`;
+	if (lifecycle.turn === "you") return `${name} is waiting on a person (${String(lifecycle.cta ?? lifecycle.stage)})${pr}; ${held}`;
+	return `${name} is ${String(lifecycle.stage)}${pr}; ${held}`;
+}
+/**
+* The product's queue as a person reads it: each live entry in order with its
+* initiative's title and where that initiative is, a halted entry with why and
+* what lifts it, and one sentence saying what the line is waiting on. The
+* route carries item ids only; each is named by one item read (when the key
+* may read the backlog), and a read the API fails leaves that entry unnamed
+* rather than failing the queue.
+*/
+async function queueView(client, product, options = { name: "all" }) {
+	const entries = (await client.listQueue(product)).data.filter((entry) => entry.state !== "settled");
+	const canName = client.hasCapability("backlog:read");
+	const blocking = blockingIndex(entries, (entry) => entry.state);
+	const toName = !canName ? [] : options.name === "all" ? entries.slice(0, NAMED_ENTRIES).map((_, index) => index) : blocking >= 0 ? [blocking] : [];
+	const settled = await Promise.allSettled(toName.map((index) => client.getBacklogItem(String(entries[index].backlogItemId))));
+	const reads = new Map(toName.map((index, at) => [index, settled[at]]));
+	let unnamed = options.name === "all" ? entries.length - toName.length : 0;
+	const rows = entries.map((entry, index) => {
+		const read = reads.get(index);
+		if (read?.status === "rejected") {
+			if (!(read.reason instanceof TaigaApiError || isNetworkFailure(read.reason))) throw read.reason;
+			unnamed += 1;
+		}
+		const item = read?.status === "fulfilled" ? read.value.data : null;
+		const lifecycle = item?.lifecycle;
+		const latestBuild = lifecycle?.latestBuild;
+		const row = {
+			position: index + 1,
+			backlogItemId: entry.backlogItemId,
+			entryState: entry.state
+		};
+		if (item) Object.assign(row, {
+			title: item.title,
+			state: item.state,
+			planningStatus: item.planningStatus,
+			needsHumanCause: item.needsHumanCause,
+			criteria: criteriaCounts(item),
+			lifecycle: lifecycle ? {
+				turn: lifecycle.turn,
+				stage: lifecycle.stage,
+				cta: lifecycle.cta
+			} : null,
+			...latestBuild ? {
+				buildId: latestBuild.id,
+				prUrl: latestBuild.prUrl ?? null
+			} : {}
+		});
+		if (entry.state === "halted") {
+			const cause = typeof entry.haltCause === "string" ? entry.haltCause : null;
+			row.halt = {
+				cause,
+				reason: (cause ? renderHalt({
+					cause,
+					params: entry.haltParams ?? {}
+				}) : "") || (typeof entry.haltReason === "string" ? entry.haltReason : "The queue stopped here."),
+				nextStep: haltNextStep(cause)
+			};
+		}
+		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.";
+	return {
+		entries: rows,
+		waitingOn: waitingOn(rows),
+		...note ? { note } : {}
+	};
+}
+function registerQueueTools(server, client) {
+	if (!client.hasCapability("products:read")) return;
+	server.registerTool("taiga_get_queue", {
+		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, 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: { productId },
+		annotations: READ_ONLY
+	}, (params) => runTool(async () => toolResult(await queueView(client, params.productId))));
+}
+//#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 = [
@@ -2014,6 +2317,7 @@ const ITEM_OUTCOME_FIELDS = [
 	"planningStatus",
 	"needsHumanCause",
 	"needsHumanDetail",
+	"autoBuild",
 	"archivedAt",
 	"lifecycle"
 ];
@@ -2036,14 +2340,22 @@ const PLAN_STEP_SUMMARY_FIELDS = [
 	"reads",
 	"createsResources"
 ];
-const outcome = (item) => toolResult(pickFields([item], ITEM_OUTCOME_FIELDS)[0]);
+/** The outcome fields of an initiative, with how many of its criteria are met. */
+const outcomeOf = (item) => {
+	const row = item;
+	return {
+		...pickFields([row], ITEM_OUTCOME_FIELDS)[0],
+		criteria: criteriaCounts(row)
+	};
+};
+const outcome = (item) => toolResult(outcomeOf(item));
 /**
 * Each tool is registered under the capability its route requires, so a
 * key sees exactly what it may call: reads on backlog:read, the create and
 * the board move on backlog:write, queueing on both backlog:write and
 * products:write (the state route checks both for a drop into queue), the
-* resume on products:write alone, as its route is (the item ID it takes
-* also comes back from a create or a queue), and the plan verdicts on
+* resume and the review gate on products:write alone, as their routes are
+* (the item ID they take also comes back from a create or a queue), and the plan verdicts on
 * products:write together with backlog:read, because the plan ID they take
 * comes only from the plan read: a key that cannot read plans has nothing
 * to feed them.
@@ -2054,12 +2366,13 @@ function registerBacklogTools(server, client) {
 	if (may("backlog:write")) registerBacklogWrites(server, client);
 	if (may("backlog:write") && may("products:write")) registerQueue(server, client);
 	if (may("products:write")) registerResume(server, client);
+	if (may("products:write")) registerReviewGate(server, client);
 	if (may("backlog:read") && may("products:write")) registerPlanVerdicts(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 and where each one is on the line (backlog, todo, queue, plan, build, done). Use this to find the item you are working on, then read its acceptance criteria and technical context with taiga_get_backlog_item. Archived items are left out unless asked for.",
+		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). Use this to find the item you are working on, then read its acceptance criteria and technical context with taiga_get_backlog_item. Archived items are left out unless asked for.",
 		inputSchema: {
 			productId,
 			status: z.enum([
@@ -2086,7 +2399,7 @@ function registerBacklogReads(server, client) {
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
 		const result = await client.listBacklogItems(params.productId, params);
-		return toolResult(page(pickFields(result.data, BACKLOG_SUMMARY_FIELDS), result.nextCursor));
+		return toolResult(page(itemRows(result.data, BACKLOG_SUMMARY_FIELDS), result.nextCursor));
 	}));
 	server.registerTool("taiga_get_backlog_item", {
 		title: "Get backlog item",
@@ -2154,21 +2467,89 @@ function registerBacklogWrites(server, client) {
 }
 /** The columns a drop into starts paid work, which the state route gates on products:write. */
 const LINE_STARTING_STATES = /* @__PURE__ */ new Set(["queue", "plan"]);
+/** Whether a failure is the API's (refused, missing, unreachable) rather than a bug here. */
+const isApiFailure$1 = (error) => error instanceof TaigaApiError || isNetworkFailure(error);
+/**
+* Whether this initiative's plan builds the moment it lands, and which scope
+* decided it: its own setting, or the product's default when it has none.
+* Null when the product cannot be read; the outcome then says so instead.
+*/
+async function reviewGate(client, item) {
+	const own = typeof item.autoBuild === "boolean" ? item.autoBuild : null;
+	try {
+		const product = own === null ? (await client.getProduct(String(item.productId))).data : {};
+		const builds = resolveAutoBuild({
+			initiative: own,
+			product: typeof product.autoBuild === "boolean" ? product.autoBuild : true
+		});
+		return {
+			buildsWithoutReview: builds,
+			decidedBy: own === null ? "product" : "initiative",
+			meaning: builds ? "The plan is built as soon as it lands; nobody reads it first." : "The line stops at the plan for a person to approve or reject it (taiga_get_plan, taiga_approve_plan)."
+		};
+	} catch (error) {
+		if (!isApiFailure$1(error)) throw error;
+		return null;
+	}
+}
+/** Where a queued initiative stands in its product's line; null, and the outcome says so, when the queue cannot be read. */
+async function placeInQueue(client, item) {
+	try {
+		const view = await queueView(client, String(item.productId), { name: "blocking" });
+		return {
+			position: view.entries.find((row) => row.backlogItemId === item.id)?.position ?? null,
+			of: view.entries.length,
+			waitingOn: view.waitingOn
+		};
+	} catch (error) {
+		if (!isApiFailure$1(error)) throw error;
+		return null;
+	}
+}
+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 (when the plan is approved, or at once if auto-build is on) a coding run that pushes commits and opens a pull request in the product repository. 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.",
+		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.",
 		inputSchema: {
 			itemId,
-			afterId: z.string().uuid().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")
+			afterId: z.string().uuid().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, ...placement } = params;
-		return outcome((await client.transitionInitiative(id, {
+		const { itemId: id, autoBuild, ...placement } = params;
+		if (autoBuild !== void 0) await client.setAutoBuild(id, autoBuild);
+		const item = (await client.transitionInitiative(id, {
 			state: "queue",
 			...placement
-		})).data);
+		})).data;
+		const [gate, queue] = await Promise.all([reviewGate(client, item), placeInQueue(client, item)]);
+		return toolResult({
+			...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." }
+		});
+	}));
+}
+function registerReviewGate(server, client) {
+	server.registerTool("taiga_set_auto_build", {
+		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, so ask the person first. Returns the initiative with the gate that now applies.",
+		inputSchema: {
+			itemId,
+			autoBuild: autoBuildInput
+		},
+		annotations: OPERATE
+	}, (params) => runTool(async () => {
+		const item = (await client.setAutoBuild(params.itemId, params.autoBuild)).data;
+		const gate = await reviewGate(client, item);
+		return toolResult({
+			...outcomeOf(item),
+			reviewGate: gate,
+			...gate ? {} : { note: "The product's default could not be read; taiga_get_product says it." }
+		});
 	}));
 }
 function registerResume(server, client) {
@@ -2239,6 +2620,31 @@ const RUN_OUTCOME_FIELDS = [
 /** How many products the org-wide list names; past this a row keeps its productId only. */
 const NAMED_PRODUCTS = 100;
 const buildId = z.string().uuid().describe("Build run ID -- get from taiga_list_builds");
+/** 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
@@ -2290,15 +2696,26 @@ function registerBuildTools(server, client) {
 	}));
 	server.registerTool("taiga_get_build", {
 		title: "Get build run",
-		description: "Get one run in full with its steps: what each step was meant to change, what it did change (commit, files), its status and any error. Use this to pick up where the coding agent stopped, or to understand the pull request it opened. Its actions list says what it accepts: stop (taiga_stop_build), resume or retry_from_failed_step (both taiga_resume_build), start_over (web UI only for now).",
-		inputSchema: { buildId },
+		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. Its actions list says what it accepts: stop (taiga_stop_build), resume or retry_from_failed_step (both taiga_resume_build), start_over (web UI only for now).",
+		inputSchema: {
+			buildId,
+			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.buildId), client.listBuildRunSteps(params.buildId)]);
-		return toolResult({
+		if (params.full) return toolResult({
 			...run.data,
 			steps: steps.data
 		});
+		const rows = steps.data;
+		return toolResult({
+			...run.data,
+			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_build", {
@@ -2341,8 +2758,66 @@ const REPOSITORY_SUMMARY_FIELDS = [
 ];
 /** How many of the latest runs to carry; taiga_list_builds 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. */
+const CONTEXT_BUILD_FIELDS = [
+	"id",
+	"runNumber",
+	"backlogItemId",
+	"targetTitle",
+	"status",
+	"failedReason",
+	"completedSteps",
+	"totalSteps",
+	"prUrl",
+	"prState",
+	"prMerged",
+	"createdAt"
+];
+/**
+* Characters of section text each of the two documents may bring by default.
+* Two of them plus the rest of the bundle stay well inside the 25k-token
+* tool result Claude Code accepts (a 67k-character bundle was refused); a
+* larger product's documents come cut, with the sections left out named.
+*/
+const DOCUMENT_BUDGET = 12e3;
+/**
+* The document without each section's citations: on a reality document they
+* are the code evidence behind every claim and as long as the text itself,
+* which a session's opening read does not need. The full read keeps them.
+* Says whether any were dropped, so the bundle can tell the reader.
+*/
+function withoutCitations(doc) {
+	const sections = isRecord(doc.data) ? sectionsOf(doc.data) : null;
+	if (!sections) return {
+		doc,
+		dropped: false
+	};
+	let dropped = false;
+	const kept = Object.fromEntries(Object.entries(sections).map(([id, section]) => {
+		if (!isRecord(section) || !("citations" in section)) return [id, section];
+		dropped = true;
+		const { citations: _citations, ...rest } = section;
+		return [id, rest];
+	}));
+	return {
+		doc: {
+			...doc,
+			data: {
+				...doc.data,
+				sections: kept
+			}
+		},
+		dropped
+	};
+}
 /** Pages of 100 the backlog part follows before it stops and says so. */
 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
+* open initiatives inside the tool result the document budget is sized for.
+*/
+const BACKLOG_IN_CONTEXT = 50;
 const PARTS = {
 	factory: "factories:read",
 	documents: "products:read",
@@ -2396,11 +2871,11 @@ async function factoryPart(client, factoryId) {
 	}
 }
 /**
-* The specification and architecture from the product's own timeline: in full
-* by default, or as section ids when the caller wants a small bundle. Null,
-* with a note, where unpublished.
+* The specification and architecture from the product's own timeline: their
+* whole sections up to a budget by default, in full or as section ids when
+* asked. Null, with a note, where unpublished.
 */
-async function documentsPart(client, product, full) {
+async function documentsPart(client, product, depth) {
 	const productId = String(product.id);
 	const origin = defaultOriginFor(product);
 	const reads = await Promise.allSettled(CONTEXT_DOCUMENT_TYPES.map((type) => client.getProductDocument(productId, type, origin)));
@@ -2410,8 +2885,26 @@ async function documentsPart(client, product, full) {
 		const read = reads[index];
 		if (read.status === "fulfilled") {
 			const doc = stripProvenance(read.value.data);
-			if (full) out[type] = doc;
-			else {
+			if (depth === "full") out[type] = doc;
+			else if (depth === "budget") {
+				const lean = withoutCitations(doc);
+				if (lean.dropped) notes.push(`The ${origin} ${type} leaves out each section's citations (its code evidence); taiga_get_product_document carries them.`);
+				const cut = budgetSections(lean.doc, DOCUMENT_BUDGET);
+				if (!cut) {
+					const small = JSON.stringify(lean.doc).length <= DOCUMENT_BUDGET;
+					out[type] = small ? lean.doc : {
+						version: doc.version,
+						sections: null
+					};
+					if (!small) notes.push(`The ${origin} ${type} is not made of sections; read it with taiga_get_product_document.`);
+				} else if (cut.omittedSections.length > 0) {
+					out[type] = {
+						...cut.doc,
+						omittedSections: cut.omittedSections
+					};
+					notes.push(`The ${origin} ${type} carries the whole sections that fit; read the ones under omittedSections with taiga_get_product_document, naming them in sections.`);
+				} else out[type] = cut.doc;
+			} else {
 				const sections = sectionsOf(doc.data ?? {});
 				if (sections) out[type] = {
 					version: doc.version,
@@ -2457,11 +2950,13 @@ const OPEN_BACKLOG_STATUSES = ["backlog", "in_progress"];
 async function backlogPart(client, productId) {
 	const open = /* @__PURE__ */ new Map();
 	let truncated = false;
+	let pageCapped = false;
 	for (const status of OPEN_BACKLOG_STATUSES) {
 		let cursor;
 		for (let pageIndex = 0;; pageIndex += 1) {
 			if (pageIndex === BACKLOG_PAGE_LIMIT) {
 				truncated = true;
+				pageCapped = true;
 				break;
 			}
 			const result = await client.listBacklogItems(productId, {
@@ -2477,9 +2972,12 @@ async function backlogPart(client, productId) {
 			cursor = result.nextCursor;
 		}
 	}
+	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: pickFields([...open.values()], BACKLOG_SUMMARY_FIELDS),
-		truncated
+		items: itemRows(rows.slice(-50), BACKLOG_SUMMARY_FIELDS),
+		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." } : {}
 	};
 }
 /**
@@ -2495,7 +2993,7 @@ async function repositoriesPart(client, productId) {
 }
 async function buildsPart(client, productId) {
 	const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data;
-	return pickFields(rows, BUILD_SUMMARY_FIELDS);
+	return pickFields(rows, CONTEXT_BUILD_FIELDS);
 }
 async function productContext(client, product, options) {
 	const productId = String(product.id);
@@ -2503,7 +3001,7 @@ async function productContext(client, product, options) {
 	const notGranted = Object.keys(PARTS).filter((part) => !granted(part));
 	const fetchers = {
 		factory: () => factoryPart(client, String(product.factoryId)),
-		documents: () => documentsPart(client, product, options.fullDocuments),
+		documents: () => documentsPart(client, product, options.documents),
 		policies: () => policiesPart(client),
 		backlog: () => backlogPart(client, productId),
 		repositories: () => repositoriesPart(client, productId),
@@ -2523,23 +3021,35 @@ async function productContext(client, product, options) {
 		else if (isApiFailure(result.reason)) unavailable[part] = unavailableReason(result.reason);
 		else throw result.reason;
 	});
-	return toolResult({
+	const result = {
 		...bundle,
 		notGranted: notGranted.map((part) => `${part} (needs ${PARTS[part]})`),
 		unavailable,
-		readNext: "Read a policy in full with taiga_get_document, another product document with taiga_get_product_document, a backlog item with taiga_get_backlog_item and a run with taiga_get_build."
+		readNext: "Read a policy in full with taiga_get_document, 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."
+	};
+	let characters = JSON.stringify(result, null, 2).length;
+	for (let measured = -1; measured !== characters;) {
+		measured = characters;
+		characters = JSON.stringify({
+			...result,
+			characters: measured
+		}, null, 2).length;
+	}
+	return toolResult({
+		...result,
+		characters
 	});
 }
 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 in full, which on a large product is several thousand tokens; pass fullDocuments: false for their section ids only. Call this first, then read what you need in full.",
+		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 bring as many whole sections as fit, about ${DOCUMENT_BUDGET / 1e3}k characters each, and name the sections left out (omittedSections) for taiga_get_product_document to read; fullDocuments: true carries them whole, tens of thousands of tokens on a large product and more than some clients accept, and false carries their section ids only. characters says how large the result is. Call this first, then read what you need.`,
 		inputSchema: {
 			productId: productId.optional(),
 			slug: slug.optional(),
 			remoteUrl: remoteUrl.optional(),
-			fullDocuments: z.boolean().default(true).describe("Carry the specification and architecture in full (default) or as section ids only")
+			fullDocuments: z.boolean().optional().describe("true carries the specification and architecture whole, false as section ids only; omit for the whole sections that fit a budget")
 		},
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
@@ -2549,7 +3059,8 @@ function registerContextTools(server, client) {
 			"remoteUrl"
 		]);
 		if ("refusal" in resolved) return toolError(resolved.refusal.code, resolved.refusal.message);
-		return productContext(client, resolved.product, { fullDocuments: params.fullDocuments });
+		const documents = params.fullDocuments === void 0 ? "budget" : params.fullDocuments ? "full" : "sectionIds";
+		return productContext(client, resolved.product, { documents });
 	}));
 }
 //#endregion
@@ -17187,7 +17698,7 @@ function registerPrompts(server, client) {
 			"item you are implementing with taiga_get_backlog_item. 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, { fullDocuments: true })).content[0]?.text ?? "{}")
+			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", {
@@ -17379,17 +17890,357 @@ function registerResources(server, client) {
 	});
 }
 //#endregion
+//#region src/tools/wait.ts
+const DEFAULT_WAIT_OPTIONS = { pollIntervalMs: 5e3 };
+/**
+* Under the 60 seconds many clients allow a call by default (the MCP SDK's
+* own request timeout), with room for the last read.
+*/
+const DEFAULT_TIMEOUT_SECONDS = 50;
+const timeoutSeconds = z.number().int().min(1).max(600).optional().describe(`How long to wait at most (default ${DEFAULT_TIMEOUT_SECONDS}). Keep it under your client's tool-call limit; many stop a call at 60 seconds.`);
+function pause(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) return resolve();
+		const timer = setTimeout(done, ms);
+		function done() {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", done);
+			resolve();
+		}
+		signal.addEventListener("abort", done, { once: true });
+	});
+}
+/** Failed reads in a row a wait rides out before it gives up and says why. */
+const TRANSIENT_FAILURES_TOLERATED = 3;
+/** A failure the next read may not hit: rate limited, the API erroring or unreachable. Not a refusal or a miss. */
+function isTransient(error) {
+	if (isNetworkFailure(error)) return true;
+	return error instanceof TaigaApiError && (error.status === 429 || error.status >= 500);
+}
+/**
+* Read until `judge` gives a verdict or the time is up. Every read is bound
+* by what is left of the timeout and by the call's cancellation, so a slow
+* API cannot hold the wait past either: a read cut short ends the wait with
+* the last state seen (none, when not even the first read came back). A
+* read that fails transiently is ridden out, a few in a row and the first
+* read included, so one 502 does not throw away minutes of waiting; a
+* refusal fails as it comes. Each
+* read that leaves the wait open reports progress when the client asked for
+* it, which also keeps a client that resets its timeout on progress from
+* cutting the wait short.
+*/
+async function waitFor(read, judge, timeoutMs, options, progress) {
+	const started = Date.now();
+	const deadline = started + timeoutMs;
+	let first = null;
+	let now = null;
+	let verdict = null;
+	let failures = 0;
+	for (let attempt = 0; !progress.signal.aborted; attempt += 1) {
+		if (attempt > 0) {
+			const left = deadline - Date.now();
+			if (left <= 0) break;
+			await pause(Math.min(options.pollIntervalMs, left), progress.signal);
+		}
+		const remaining = deadline - Date.now();
+		if (progress.signal.aborted || remaining <= 0) break;
+		const bound = AbortSignal.timeout(remaining);
+		try {
+			now = await read(AbortSignal.any([progress.signal, bound]));
+			first ??= now;
+			failures = 0;
+		} catch (error) {
+			if (bound.aborted || progress.signal.aborted) break;
+			failures += 1;
+			if (!isTransient(error) || failures >= TRANSIENT_FAILURES_TOLERATED) throw error;
+			continue;
+		}
+		verdict = judge(now, first);
+		if (verdict) break;
+		if (attempt > 0 && progress.progressToken !== void 0) await progress.sendNotification({
+			method: "notifications/progress",
+			params: {
+				progressToken: progress.progressToken,
+				progress: Date.now() - started,
+				total: timeoutMs,
+				message: "Still waiting"
+			}
+		}).catch(() => void 0);
+	}
+	const waitedSeconds = Math.round((Date.now() - started) / 1e3);
+	if (verdict) return {
+		...verdict,
+		waitedSeconds,
+		now
+	};
+	return {
+		reached: false,
+		stoppedBecause: progress.signal.aborted ? "cancelled" : "timeout",
+		waitedSeconds,
+		now
+	};
+}
+const SETTLED_RUN = new Set(BUILD_RUN_TERMINAL_STATUSES);
+/**
+* A pull request that is open now. A run keeps its prUrl after the pull
+* request merges or closes, so the URL alone says one existed, not that it
+* is open; the mirrored state and the merged latch say which. An unknown
+* state (null, just opened) counts as open.
+*/
+function prIsOpen(run) {
+	return typeof run.prUrl === "string" && run.prUrl !== "" && run.prMerged !== true && run.prState !== "closed";
+}
+const ITEM_CONDITIONS = [
+	"changed",
+	"planned",
+	"your_turn",
+	"pr_open",
+	"run_settled",
+	"done"
+];
+const latestBuildOf = (item) => item.lifecycle?.latestBuild ?? null;
+const lifecycleOf = (item) => item.lifecycle ?? {};
+/** What "changed" compares: where the item is, whose turn it is and how its latest run stands. */
+function itemSignature(item) {
+	const lifecycle = lifecycleOf(item);
+	const run = latestBuildOf(item);
+	return JSON.stringify([
+		item.state,
+		item.planningStatus,
+		item.needsHumanCause,
+		lifecycle.stage,
+		lifecycle.turn,
+		lifecycle.cta,
+		run?.id,
+		run?.status,
+		run?.completedSteps,
+		run?.prUrl,
+		run?.prState,
+		run?.prMerged
+	]);
+}
+/**
+* Whether the initiative waits on a person now: yes, no, or unknown. The
+* lifecycle says `turn: 'you'` for every landed plan (`start_build`), but a
+* plan whose review gate is open is waiting for the Build slot, not for
+* anyone: the queue keeps such an entry active and starts it on its own. When
+* the gate cannot be resolved (no gate of its own, and the product's default
+* unreadable) the answer is unknown, and the wait says so rather than guess.
+*/
+function personTurn(item, gate) {
+	const lifecycle = lifecycleOf(item);
+	if (lifecycle.turn !== "you") return "no";
+	if (lifecycle.cta !== "start_build") return "yes";
+	const own = typeof item.autoBuild === "boolean" ? item.autoBuild : null;
+	const product = typeof gate.product === "boolean" ? gate.product : null;
+	if (own === null && product === null) return "unknown";
+	return resolveAutoBuild({
+		initiative: own,
+		product: product ?? true
+	}) ? "no" : "yes";
+}
+function itemHolds(until, item, first, gate) {
+	const lifecycle = lifecycleOf(item);
+	const run = latestBuildOf(item);
+	switch (until) {
+		case "changed": return itemSignature(item) !== itemSignature(first);
+		case "planned": return item.planningStatus === "planned";
+		case "your_turn": return personTurn(item, gate) === "yes";
+		case "pr_open": return run !== null && prIsOpen(run);
+		case "run_settled": return run !== null && SETTLED_RUN.has(String(run.status));
+		case "done": return lifecycle.stage === "done";
+	}
+}
+function judgeItem(until, gate) {
+	return (item, first) => {
+		if (itemHolds(until, item, first, gate)) return { reached: true };
+		if (until === "changed") return null;
+		if (typeof item.needsHumanCause === "string") return {
+			reached: false,
+			stoppedBecause: `needs a person: ${item.needsHumanCause}`
+		};
+		const lifecycle = lifecycleOf(item);
+		const turn = personTurn(item, gate);
+		if (until !== "your_turn" && turn === "yes") return {
+			reached: false,
+			stoppedBecause: `waits on a person: ${String(lifecycle.cta ?? lifecycle.stage)}`
+		};
+		if (turn === "unknown") return {
+			reached: false,
+			stoppedBecause: "the plan has landed, and whether it waits for a review is unknown: the product's default could not be read (it needs products:read)"
+		};
+		if (until === "planned" && item.planningStatus === "failed") return {
+			reached: false,
+			stoppedBecause: "planning failed"
+		};
+		const stage = lifecycleOf(item).stage;
+		if (stage === "canceled" || until !== "done" && stage === "done") return {
+			reached: false,
+			stoppedBecause: `the initiative is ${String(stage)}`
+		};
+		return null;
+	};
+}
+/** 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);
+	return {
+		...pickFields([item], [
+			"id",
+			"title",
+			"state",
+			"planningStatus",
+			"needsHumanCause",
+			"needsHumanDetail",
+			"autoBuild"
+		])[0],
+		lifecycle: pickFields([lifecycleOf(item)], [
+			"turn",
+			"stage",
+			"cta",
+			"planFailureCause"
+		])[0],
+		latestBuild: run ? pickFields([run], [
+			"id",
+			"status",
+			"completedSteps",
+			"totalSteps",
+			"prUrl",
+			"prState",
+			"prMerged",
+			"actions"
+		])[0] : null,
+		criteria: criteriaCounts(item)
+	};
+}
+const BUILD_CONDITIONS = [
+	"changed",
+	"step_done",
+	"pr_open",
+	"settled"
+];
+const RUN_REPORT_FIELDS = [
+	"id",
+	"backlogItemId",
+	"targetTitle",
+	"status",
+	"failedReason",
+	"completedSteps",
+	"totalSteps",
+	"prUrl",
+	"prState",
+	"prDraft",
+	"prMerged",
+	"actions"
+];
+const runSignature = (run) => JSON.stringify([
+	run.status,
+	run.completedSteps,
+	run.prUrl,
+	run.prState,
+	run.prMerged
+]);
+function judgeBuild(until) {
+	return (run, first) => {
+		if (until === "changed" ? runSignature(run) !== runSignature(first) : until === "step_done" ? Number(run.completedSteps ?? 0) > Number(first.completedSteps ?? 0) : until === "pr_open" ? prIsOpen(run) : SETTLED_RUN.has(String(run.status))) return { reached: true };
+		if (until !== "changed" && SETTLED_RUN.has(String(run.status))) return {
+			reached: false,
+			stoppedBecause: `the run is ${String(run.status)}`
+		};
+		return null;
+	};
+}
+function registerWaitTools(server, client, options) {
+	if (client.hasCapability("backlog:read")) server.registerTool("taiga_wait_for_backlog_item", {
+		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: {
+			itemId: z.string().uuid().describe("Backlog item ID -- get from taiga_list_backlog_items"),
+			until: z.enum(ITEM_CONDITIONS).describe("What to wait for"),
+			timeoutSeconds
+		},
+		annotations: READ_ONLY
+	}, (params, extra) => runTool(async () => {
+		const gate = { product: void 0 };
+		const read = async (signal) => {
+			const item = (await client.getBacklogItem(params.itemId, 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;
+			}).catch((error) => {
+				if (error instanceof TaigaApiError && (error.status === 403 || error.status === 404)) return null;
+				throw error;
+			}) : null;
+			return item;
+		};
+		const { now, ...outcome } = await waitFor(read, judgeItem(params.until, gate), (params.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1e3, options, {
+			progressToken: extra._meta?.progressToken,
+			sendNotification: extra.sendNotification,
+			signal: extra.signal
+		});
+		return toolResult({
+			until: params.until,
+			...outcome,
+			item: now ? itemReport(now) : null
+		});
+	}));
+	if (client.hasCapability("products:read")) server.registerTool("taiga_wait_for_build", {
+		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: {
+			buildId: z.string().uuid().describe("Build run ID -- get from taiga_list_builds"),
+			until: z.enum(BUILD_CONDITIONS).describe("What to wait for"),
+			timeoutSeconds
+		},
+		annotations: READ_ONLY
+	}, (params, extra) => 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, {
+			progressToken: extra._meta?.progressToken,
+			sendNotification: extra.sendNotification,
+			signal: extra.signal
+		});
+		return toolResult({
+			until: params.until,
+			...outcome,
+			run: now ? pickFields([now], RUN_REPORT_FIELDS)[0] : null
+		});
+	}));
+}
+//#endregion
 //#region src/tools/index.ts
 /**
+* Every tool refuses an argument it does not take. A plain object schema
+* strips one silently: a review note passed to a tool with no place for it
+* vanished and the call still succeeded, and a misspelt option quietly
+* became its default. Strict, the call fails with "Unrecognized key" and the
+* model learns the tool's real shape. Applied here, once, so no tool can be
+* registered without it.
+*/
+function withStrictInputs(server) {
+	const register = server.registerTool.bind(server);
+	server.registerTool = ((name, config, callback) => {
+		const shape = config.inputSchema;
+		const isRawShape = typeof shape === "object" && shape !== null && !("_zod" in shape);
+		return register(name, isRawShape ? {
+			...config,
+			inputSchema: z.strictObject(shape)
+		} : config, callback);
+	});
+	return server;
+}
+/**
 * Register all MCP tools, resources and prompts based on the API key's effective capabilities.
 * Only tools matching the key's scopes are registered -- the AI assistant
 * never sees tools it can't use.
 */
-function registerAllTools(server, client) {
+function registerAllTools(server, client, options = {}) {
+	withStrictInputs(server);
 	registerProductTools(server, client);
 	registerDocumentTools(server, client);
 	registerBacklogTools(server, client);
 	registerBuildTools(server, client);
+	registerQueueTools(server, client);
+	registerWaitTools(server, client, options.wait ?? DEFAULT_WAIT_OPTIONS);
 	registerContextTools(server, client);
 	registerResources(server, client);
 	registerPrompts(server, client);
@@ -17435,12 +18286,19 @@ const SERVER_INSTRUCTIONS = [
 	"every product the key can see, and active: true the ones executing now.",
 	"",
 	"**Operating the line** (taiga_create_backlog_item / taiga_queue_backlog_item / taiga_move_backlog_item /",
-	"taiga_resume_backlog_item / taiga_get_plan / taiga_approve_plan / taiga_reject_plan / taiga_stop_build /",
-	"taiga_resume_build): create an initiative, put it in the queue the coding agent works, move it on the",
-	"board, read and approve or reject its plan, stop or resume a run. Queueing, approving and resuming start",
-	"paid agent work that pushes commits and opens pull requests; stopping interrupts it. Tell the person what",
-	"you are about to start or stop and wait for their yes before calling these; a client that prompts on",
-	"destructive tools does that for you. A refusal (CONFLICT) carries the API reason: say it as it is.",
+	"taiga_resume_backlog_item / taiga_set_auto_build / taiga_get_plan / taiga_approve_plan / taiga_reject_plan /",
+	"taiga_stop_build / taiga_resume_build): create an initiative, put it in the queue the coding agent works,",
+	"move it on the board, decide whether its plan waits for a review (autoBuild: false) or is built at once, read",
+	"and approve or reject its plan, stop or resume a run. Queueing, approving and resuming start paid agent work",
+	"that pushes commits and opens pull requests; stopping interrupts it. Tell the person what you are about to",
+	"start or stop and wait for their yes before calling these; 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): the queue",
+	"read says what the line is waiting on (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).",
 	"",
 	"**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:",
@@ -17452,7 +18310,8 @@ const SERVER_INSTRUCTIONS = [
 	"",
 	"Workflow: start with taiga_get_product_context, naming the product by its git remote URL inside a checkout",
 	"(git remote get-url origin), else by slug or ID from taiga_list_products. It returns the product, the",
-	"factory instructions, the specification and architecture, every policy as its section ids, the open backlog",
+	"factory instructions, the specification and architecture as the whole sections that fit (the rest named for",
+	"taiga_get_product_document to read by section), every policy as its section ids, the open backlog",
 	"items, the repositories and the latest runs in one call, and names any part it could not read. Then read",
 	"what you need in full: a policy with taiga_get_document, a backlog item with taiga_get_backlog_item.",
 	"Without it, use taiga_list_factories and taiga_list_products, then read the factory instructions,",