@taiga-ai/mcp-server 0.22.0-dev.457 → 0.23.0-dev.459

package/dist/index.js

@@ -2379,7 +2379,7 @@ function inProductWords(value) {
 }
 /** The API's 404 sentence in the product's words: "Backlog item not found" is an initiative not found. */
 function inProductWording(said) {
-	return said.replace(/^Backlog item not found/i, "Initiative not found").replace(/^Build run step not found/i, "Run step not found").replace(/^Build run not found/i, "Run not found").replace(/^Custom document not found/i, "Knowledge file not found").replace(/^This product already has a repository\. Change it instead of linking another\./i, "This product already has a repository. Pass replacesRepositoryId to swap it in one step, or taiga_unlink_repository first (taiga_list_product_repositories gives its ID).");
+	return said.replace(/^Backlog item not found/i, "Initiative not found").replace(/^Build run step not found/i, "Run step not found").replace(/^Build run not found/i, "Run not found").replace(/^Custom document not found/i, "Knowledge file not found").replace(/^(Branch "[^"]*" does not exist in \S+?)\.?$/i, "$1. taiga_list_repository_branches lists the branches it has.").replace(/^This product already has a repository\. Change it instead of linking another\./i, "This product already has a repository. Pass replacesRepositoryId to swap it in one step, or taiga_unlink_repository first (taiga_list_product_repositories gives its ID).");
 }
 /** A successful tool result: one JSON text block the model reads. */
 function toolResult(value) {
@@ -3108,6 +3108,25 @@ async function resolveProductRef(client, ref, accepted, usage) {
 	}
 	return { product: products[0] };
 }
+/**
+* NOT_FOUND for a factory ID the key cannot see; null when it exists or the read failed. A key that cannot read
+* factories cannot tell an empty factory from a wrong ID, and the answer says so.
+*/
+async function factoryMissing(client, factoryId) {
+	if (!client.hasCapability("factories:read")) return toolResult({
+		data: [],
+		nextCursor: null,
+		note: "No products here. This key cannot read factories, so whether that factoryId exists was not checked."
+	});
+	try {
+		await client.getFactory(factoryId);
+		return null;
+	} catch (error) {
+		if (error instanceof TaigaApiError && error.status === 404) return toolError("NOT_FOUND", "Factory not found. taiga_list_factories lists the factories the key can see.");
+		if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
+		throw error;
+	}
+}
 function registerProductTools(server, client) {
 	if (client.hasCapability("factories:read")) server.registerTool("taiga_list_factories", {
 		title: "List factories",
@@ -3147,6 +3166,10 @@ function registerProductTools(server, client) {
 			const { query: text, ...filters } = params;
 			if (text === void 0) {
 				const result = await client.listProducts(filters);
+				if (result.data.length === 0 && filters.factoryId && !filters.cursor) {
+					const missing = await factoryMissing(client, filters.factoryId);
+					if (missing) return missing;
+				}
 				return toolResult(page(await withFactoryNames(client, pickFields(result.data, PRODUCT_SUMMARY_FIELDS)), result.nextCursor));
 			}
 			if (params.cursor !== void 0) return toolError("VALIDATION_ERROR", SEARCH_WITH_CURSOR);
@@ -3156,6 +3179,10 @@ function registerProductTools(server, client) {
 				limit: 100,
 				cursor
 			}), text, (row) => [row.name, row.slug], params.limit ?? 25);
+			if (found.rows.length === 0 && filters.factoryId) {
+				const missing = await factoryMissing(client, filters.factoryId);
+				if (missing) return missing;
+			}
 			return toolResult({
 				...page(await withFactoryNames(client, pickFields(found.rows, PRODUCT_SUMMARY_FIELDS)), null),
 				...found.more ? { more: SEARCH_NOTE } : {}
@@ -3556,7 +3583,6 @@ const BUILD_SUMMARY_FIELDS = [
 	"planId",
 	"status",
 	"failedReason",
-	"runtime",
 	"repositoryFullName",
 	"branch",
 	"baseBranch",
@@ -3696,16 +3722,34 @@ function runOutcome(run) {
 	};
 }
 /**
+* What each failedReason means for the next move (PRO-2800): reviewers met dispatch_rejected and agent_reported as
+* bare enums. As @taiga/types documents them.
+*/
+const FAILED_REASON_MEANS = {
+	agent_reported: "the agent stopped and said why (error); resuming would likely hit the same wall",
+	server_orphan: "the run stopped reporting (its machine died or ran out of memory); resuming can recover",
+	agent_stalled: "the agent kept running but stopped making progress; resuming can recover",
+	user_stopped: "it was stopped, by a person or because its initiative was settled",
+	timeout: "it ran past its time limit; resuming continues from the unfinished step",
+	dispatch_rejected: "the agent never started (its environment or credentials failed); resuming dispatches it again",
+	context_exhaustion: "the agent ran out of context on a step; resuming starts that step fresh"
+};
+/**
 * 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). A list row leaves the full error
 * text out: its first sentence is in the outcome, and taiga_get_run has it all.
 */
 function readableRun(run, opts = {}) {
-	const { prDraft, error, reviewEscalation, ...rest } = run;
+	const { prDraft, error, reviewEscalation, runtime: _runtime, ...rest } = run;
 	const said = runOutcome(run);
+	const means = FAILED_REASON_MEANS[String(run["failedReason"])];
+	const hardening = run["hardeningResult"];
+	const blocking = typeof hardening?.blockingFindings === "number" ? hardening.blockingFindings : 0;
 	return {
 		...rest,
+		...means ? { failedReasonMeans: means } : {},
+		...blocking > 0 ? { hardeningNote: `Hardening ended with ${blocking} blocking finding${blocking === 1 ? "" : "s"} it could not fix; the run records how many, not which.` } : {},
 		...opts.row || error === void 0 ? {} : { error },
 		...opts.row || reviewEscalation === void 0 ? {} : { reviewEscalation },
 		...typeof rest["prNumber"] === "number" || rest["prUrl"] ? { prDraft } : {},
@@ -3873,7 +3917,7 @@ function registerBuildTools(server, client) {
 	}));
 	server.registerTool("taiga_get_run", {
 		title: "Get run",
-		description: "Read one run with its steps: outcome, disposition, pull request, hardening, and per step its title, status, commit, files changed, verification and headline (first paragraph of the agent's report). verification is Taiga's own check after the step (tests, lint, build), so a docs-only step can fail on the repository's failing tests. A failed or stopped run has stoppedIn and lastProgressAt. full: true adds complete instructions and reports. actions: resume and retry_from_failed_step are taiga_resume_initiative; start_over is web only; to stop it, move the initiative out of Build. A maintenance run has no initiative and is retried from its finding.",
+		description: "Read one run with its steps: outcome, disposition, pull request, hardening, and per step its title, status, commit, files changed, verification and headline (first paragraph of the agent's report). verification is Taiga's own check after the step (tests, lint, build), so a docs-only step can fail on the repository's failing tests (verificationNote says when one failed throughout). A failed or stopped run has stoppedIn, lastProgressAt and failedReasonMeans (what its failedReason means). full: true adds complete instructions and reports. actions: resume and retry_from_failed_step are taiga_resume_initiative; start_over is 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)")
@@ -4271,6 +4315,40 @@ const outcomeOf = (item) => withSituation(item, {
 	criteria: criteriaCounts(item)
 });
 const outcome = (item) => toolResult(outcomeOf(item));
+/** The statuses an initiative in each board column can have: the API keeps in_progress after a first run. */
+const COLUMN_STATUSES = {
+	backlog: [
+		"all",
+		"open",
+		"backlog",
+		"in_progress"
+	],
+	todo: [
+		"all",
+		"open",
+		"backlog",
+		"in_progress"
+	],
+	queue: [
+		"all",
+		"open",
+		"backlog",
+		"in_progress"
+	],
+	plan: [
+		"all",
+		"open",
+		"backlog",
+		"in_progress"
+	],
+	build: [
+		"all",
+		"open",
+		"in_progress"
+	],
+	done: ["all", "done"],
+	canceled: ["all", "canceled"]
+};
 /**
 * Each tool is registered under the capability its route requires, so a
 * key sees exactly what it may call: reads on backlog:read; the board move on
@@ -4334,6 +4412,7 @@ function registerBacklogReads(server, client) {
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
 		const { query, state, status = state === void 0 ? "open" : "all", ...filters } = params;
+		if (state !== void 0 && !COLUMN_STATUSES[state].includes(status)) return toolError("VALIDATION_ERROR", `No initiative is in the ${state} column with status ${status}: pass state alone, or a status it can have (${COLUMN_STATUSES[state].join(", ")}).`);
 		const apiFilters = {
 			...filters,
 			status: status === "open" || status === "all" ? void 0 : status
@@ -4765,16 +4844,22 @@ function registerMaintenanceTools(server, client) {
 		const listed = controls.filter((c) => Number(c.divergenceCount ?? 0) > 0 || Number(c.findingCount ?? 0) > 0);
 		const summary = standingSummary(standing);
 		const note = standing.assessment?.state === "never" ? "Never assessed: the documents have not been checked against the policies yet, so nothing here is an all-clear. An assessment runs when the reality documents are derived or refreshed (taiga_refresh_reality_documents, paid work: ask first)." : null;
+		const resolvedAny = Array.isArray(standing.resolvedDivergences) && standing.resolvedDivergences.length > 0;
+		const wording = violations.length > 0 || resolvedAny ? { wordingNote: "A violation's evidence is from its assessedAt; its title and summary may be from when it was first recorded. Where they disagree, the evidence is current." } : {};
 		if (params.violationId) {
 			const one = [...violations, ...Array.isArray(standing.resolvedDivergences) ? standing.resolvedDivergences : []].find((violation) => violation["id"] === params.violationId);
 			if (!one) return toolError("NOT_FOUND", "No violation with that ID on this product; this tool without violationId lists them.");
-			return toolResult(one);
+			return toolResult({
+				...one,
+				...wording
+			});
 		}
 		if (params.full) {
 			const resolvedAll = Array.isArray(standing.resolvedDivergences) ? standing.resolvedDivergences : [];
 			return toolResult({
 				summary,
 				...note ? { note } : {},
+				...wording,
 				...standing,
 				controls: listed,
 				divergences: cutLongText(violations),
@@ -4785,6 +4870,7 @@ function registerMaintenanceTools(server, client) {
 		return toolResult({
 			summary,
 			...note ? { note } : {},
+			...wording,
 			productId: standing.productId,
 			hasPolicies: standing.hasPolicies,
 			assessment: standing.assessment,
@@ -4866,775 +4952,831 @@ function registerMaintenanceTools(server, client) {
 	}));
 }
 //#endregion
-//#region src/tools/context.ts
+//#region src/tools/inbox.ts
 /**
-* One call at the start of a coding session: everything the model would
-* otherwise collect in eight, fanned out here. Each part stands on its own
-* (Promise.allSettled): a part the API refuses or fails is named under
-* `unavailable` with what the API said, a part the key's capabilities do not
-* cover is named under `notGranted`, and neither is ever shown as empty. A
-* failure that is not the API's (a bug in this code) is not downgraded; it
-* fails the call so it surfaces.
+* 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.
 */
-/** The two documents a coding session starts from; the rest are a read away. */
-const CONTEXT_DOCUMENT_TYPES = ["specification", "architecture"];
-const REPOSITORY_SUMMARY_FIELDS = [
-	"id",
-	"provider",
-	"repositoryName",
-	"repositoryUrl",
-	"effectiveBranch",
-	"isManaged"
-];
-/** 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_run has the rest. */
-const CONTEXT_BUILD_FIELDS = [
+const ITEM_FIELDS = [
 	"id",
-	"runNumber",
-	"backlogItemId",
-	"targetTitle",
+	"productId",
+	"productName",
+	"category",
+	"kind",
+	"subjectType",
+	"subjectId",
+	"title",
+	"summary",
 	"status",
-	"failedReason",
-	"completedSteps",
-	"totalSteps",
-	"baseBranch",
-	"prNumber",
-	"prUrl",
-	"prState",
-	"prMerged",
-	"prDraft",
-	"reviewEscalation",
-	"error",
-	"createdAt"
+	"blocking",
+	"snoozedUntil",
+	"createdAt",
+	"resolvedAt"
 ];
+const DAY_MS = 864e5;
+/** When an item stopped waiting: its resolution, or now while it is open. */
+function waitedUntil(resolvedAt, now) {
+	const at = typeof resolvedAt === "string" ? Date.parse(resolvedAt) : NaN;
+	return Number.isNaN(at) ? now : at;
+}
 /**
-* 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.
+* The read that opens an item's subject (PRO-2800): rows carried subjectType and subjectId, and the reviewing agent
+* had to infer which tool takes them.
+*/
+function readWith(row, backlogRead) {
+	switch (row["subjectType"]) {
+		case "build_run": return "taiga_get_run (runId: subjectId)";
+		case "backlog_item": return backlogRead ? "taiga_get_plan (initiativeId: subjectId)" : void 0;
+		case "product_document": return "taiga_list_product_documents (productId)";
+		case "inbox_task": return "taiga_list_setup_tasks (productId)";
+		case "product": return {
+			review_backlog: backlogRead ? "taiga_list_initiatives (productId)" : void 0,
+			review_maintenance: "taiga_list_findings (productId)",
+			review_policy: "taiga_get_policy_standing (productId)",
+			review_doc: "taiga_list_product_documents (productId)"
+		}[String(row["kind"])];
+		default: return;
+	}
+}
+/** A summary past its first sentence: review_doc rows quoted two documents, 800 to 1,200 characters each. */
+const SUMMARY_LIMIT = 200;
+function firstSentence(text) {
+	if (typeof text !== "string") return text;
+	const head = text.split(/\n/)[0].trim();
+	if (head.length <= SUMMARY_LIMIT) return head.length < text.trim().length ? `${head} (full: true has the rest)` : head;
+	const cut = head.slice(0, SUMMARY_LIMIT);
+	const end = Math.max(cut.lastIndexOf(". "), cut.lastIndexOf("; "));
+	return `${end > 40 ? cut.slice(0, end + 1) : cut}... (full: true has the rest)`;
+}
+/** A row as an agent reads it: the pull request to open when there is one, and how many days it has waited. */
+function itemRow(row, now, full, backlogRead) {
+	const { snoozedUntil, resolvedAt, ...rest } = pickFields([row], ITEM_FIELDS)[0];
+	const metadata = row["metadata"] ?? {};
+	const created = typeof row["createdAt"] === "string" ? Date.parse(row["createdAt"]) : NaN;
+	const { summary, status, blocking, ...lean } = rest;
+	const read = readWith(row, backlogRead);
+	return {
+		...lean,
+		...full ? { summary } : row["kind"] === "review_pr" ? {} : { summary: firstSentence(summary) },
+		...full || status !== "open" ? { status } : {},
+		...full || blocking === true ? { blocking } : {},
+		...read ? { readWith: read } : {},
+		...snoozedUntil ? { snoozedUntil } : {},
+		...resolvedAt ? { resolvedAt } : {},
+		...typeof metadata["prUrl"] === "string" ? { prUrl: metadata["prUrl"] } : {},
+		...Number.isNaN(created) ? {} : { waitingDays: Math.floor((waitedUntil(resolvedAt, now) - created) / DAY_MS) },
+		...full ? { metadata: row["metadata"] } : {}
+	};
+}
+/**
+* What is open, counted by product and kind: the answer to "what needs attention" without reading every row. An item
+* that no longer stands is counted under stale, not open or byKind, so nobody subtracts by hand (PRO-2800).
 */
-const DOCUMENT_BUDGET = 12e3;
+function summaryOf(rows, stale) {
+	const byProduct = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = String(row["productId"]);
+		const entry = byProduct.get(key) ?? (row["productName"] ? {
+			productId: key,
+			product: row["productName"],
+			open: 0,
+			byKind: {}
+		} : {
+			productId: key,
+			open: 0,
+			byKind: {}
+		});
+		if (stale.has(String(row["id"]))) entry.stale = (entry.stale ?? 0) + 1;
+		else {
+			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);
+}
+/** Pull request reviews checked against their run and initiative; past this a row is left as it is. */
+const STALE_CHECKS = 10;
 /**
-* 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.
+* Which "Review & merge" items no longer stand, and why (PRO-2800): the run's
+* pull request closed or merged, or its initiative was canceled or finished
+* without it. Two reviewing agents counted such leftovers as live gates; the
+* row still is open in Action Required, so this says what it is now rather
+* than hiding it. Best effort, a handful of runs: a failed read leaves the
+* row as it was.
 */
-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];
+async function staleReviews(client, rows) {
+	const byId = new Map(rows.filter((row) => row["kind"] === "review_pr" && row["subjectType"] === "build_run").map((row) => [String(row["id"]), row]));
+	const candidates = [...byId.values()].slice(0, STALE_CHECKS);
+	let unchecked = byId.size - candidates.length;
+	const out = /* @__PURE__ */ new Map();
+	await Promise.all(candidates.map(async (row) => {
+		try {
+			const run = (await client.getBuildRun(String(row["subjectId"]))).data;
+			if (run["prMerged"] === true) return void out.set(String(row["id"]), "its pull request has merged");
+			if (run["prState"] === "closed") return void out.set(String(row["id"]), "its pull request was closed");
+			if (typeof run["backlogItemId"] !== "string") return;
+			if (!client.hasCapability("backlog:read")) return void (unchecked += 1);
+			const item = (await client.getBacklogItem(run["backlogItemId"])).data;
+			if (item["state"] === "canceled" || item["status"] === "canceled") out.set(String(row["id"]), "its initiative was canceled; the pull request is still open on the forge");
+			else if (item["state"] === "done" || item["status"] === "done") out.set(String(row["id"]), "its initiative is done; this run is not the one that landed it");
+		} catch (error) {
+			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
+			unchecked += 1;
+		}
 	}));
+	unchecked += await staleBacklogReviews(client, rows, out);
 	return {
-		doc: {
-			...doc,
-			data: {
-				...doc.data,
-				sections: kept
-			}
-		},
-		dropped
+		stale: out,
+		unchecked
 	};
 }
 /**
-* How much of the two documents the bundle carries. The outline by default
-* (PRO-2778): the whole sections that fit a budget made the opening read run
-* to 43k characters for an active product, most of it prose a "where does it
-* stand" question never reads.
+* "Review Initiatives" items whose product has no initiative left in its backlog or todo column (PRO-2800): two reviews found one
+* waiting 15 days on a product whose initiatives had all moved on, with nothing an agent could act on. Best effort,
+* a handful of products; returns how many could not be checked.
 */
-const DOCUMENT_DEPTHS = [
-	"outline",
-	"budget",
-	"full"
-];
-/** Pages of 100 the backlog part follows before it stops and says so. */
-const BACKLOG_PAGE_LIMIT = 10;
+async function staleBacklogReviews(client, rows, out) {
+	const asks = [...new Map(rows.filter((row) => row["kind"] === "review_backlog" && typeof row["productId"] === "string").map((row) => [String(row["id"]), row])).values()];
+	if (asks.length === 0) return 0;
+	if (!client.hasCapability("backlog:read")) return asks.length;
+	const checked = [...new Set(asks.map((row) => String(row["productId"])))].slice(0, STALE_CHECKS);
+	let unchecked = asks.filter((row) => !checked.includes(String(row["productId"]))).length;
+	const empty = /* @__PURE__ */ new Set();
+	await Promise.all(checked.map(async (productId) => {
+		try {
+			const pages = await Promise.all(["backlog", "in_progress"].map((status) => client.listBacklogItems(productId, {
+				status,
+				limit: 100
+			})));
+			if (pages.some((page) => page.data.some((item) => item.state === "backlog" || item.state === "todo"))) return;
+			if (pages.some((page) => page.nextCursor)) {
+				unchecked += asks.filter((row) => row["productId"] === productId).length;
+				return;
+			}
+			empty.add(productId);
+		} catch (error) {
+			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
+			unchecked += asks.filter((row) => row["productId"] === productId).length;
+		}
+	}));
+	for (const row of asks) if (empty.has(String(row["productId"]))) out.set(String(row["id"]), "no initiative is in the backlog or todo now: the ones it asked about have moved on");
+	return unchecked;
+}
 /**
-* Open items the bundle carries, the newest of those read; past this it says truncated and
-* taiga_list_initiatives pages the rest. Keeps a product with hundreds of
-* open initiatives inside the tool result the document budget is sized for.
+* One product's Action Required as counts, the way the list's summary counts them: open is what still stands and is
+* not put off, stale and snoozed are counted apart. The product context reports these, so the two reads agree.
 */
-const BACKLOG_IN_CONTEXT = 50;
-const PARTS = {
-	factory: "factories:read",
-	documents: "products:read",
-	policies: "tenant:documents:read",
-	initiatives: "backlog:read",
-	repositories: "products:read",
-	runs: "products:read",
-	actionRequired: "products:read",
-	maintenance: "products:read",
-	policyStanding: "products:read"
-};
-/** What the API said when a part failed, in the words the bundle reports. */
-function unavailableReason(reason) {
-	if (reason instanceof TaigaApiError) return apiFailureText(reason);
-	return `the API could not be reached: ${networkFailureDetail(reason)}`;
-}
-/** Whether a failed part is the API's doing; anything else is ours and propagates. */
-function isApiFailure$1(reason) {
-	return reason instanceof TaigaApiError || isNetworkFailure(reason);
+async function attentionCounts(client, rows) {
+	const now = Date.now();
+	const due = rows.filter((row) => isDue(row, now));
+	const { stale, unchecked } = await staleReviews(client, due);
+	const [entry] = summaryOf(due, stale);
+	const snoozed = rows.length - due.length;
+	return {
+		open: entry ? Number(entry["open"]) : 0,
+		byKind: entry ? entry["byKind"] : {},
+		...entry && typeof entry["stale"] === "number" ? { stale: entry["stale"] } : {},
+		...snoozed > 0 ? { snoozed } : {},
+		...unchecked > 0 ? { staleNote: `${unchecked} review${unchecked === 1 ? " was" : "s were"} not checked for staleness and count as open.` } : {}
+	};
 }
-function isNotFound$1(reason) {
-	return reason instanceof TaigaApiError && reason.status === 404;
+/** An item the team has not put off: the page hides one until its snooze ends, and so does this. */
+function isDue(row, now) {
+	return !(row["status"] === "snoozed" && typeof row["snoozedUntil"] === "string" && Date.parse(row["snoozedUntil"]) > now);
 }
-/** The factory's standing guidance in full; null, with a note, when none is published or it is not section-shaped. */
-async function factoryPart(client, factoryId) {
-	const factory = (await client.getFactory(factoryId)).data;
-	const base = {
-		id: factory.id,
-		name: factory.name,
-		slug: factory.slug
-	};
-	try {
-		const doc = (await client.getFactoryDocument(factoryId, "factory_instructions")).data;
-		const sections = sectionsOf(doc.data);
-		if (!sections) return {
-			...base,
-			instructions: null,
-			instructionsVersion: doc.version,
-			note: "The published instructions are not made of sections; read them with taiga_get_factory_document."
-		};
-		return {
-			...base,
-			instructions: instructionsText(sections),
-			instructionsVersion: doc.version
-		};
-	} catch (error) {
-		if (!isNotFound$1(error)) throw error;
-		return {
-			...base,
-			instructions: null,
-			instructionsVersion: null,
-			note: "This factory has not published instructions yet."
-		};
-	}
-}
-/**
-* The specification and architecture from the product's own timeline: their
-* outline by default, the whole sections up to a budget or in full when
-* asked. Null, with a note, where unpublished.
-*/
-async function documentsPart(client, product, depth) {
-	const productId = product.id;
-	const origin = defaultOriginFor(product);
-	const reads = await Promise.allSettled(CONTEXT_DOCUMENT_TYPES.map((type) => client.getProductDocument(productId, type, origin)));
-	const out = { origin };
-	const notes = [];
-	CONTEXT_DOCUMENT_TYPES.forEach((type, index) => {
-		const read = reads[index];
-		if (read.status === "fulfilled") {
-			const doc = stripProvenance(read.value.data);
-			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) {
-					const outline = Object.keys(sections).map((id) => ({
-						id,
-						characters: sectionContent(sections, id)?.length ?? 0
-					}));
-					out[type] = {
-						version: doc.version,
-						sections: outline
-					};
-				} else {
-					out[type] = {
-						version: doc.version,
-						sections: null
-					};
-					notes.push(`The ${origin} ${type} is not made of sections; read it with taiga_get_product_document.`);
-				}
-			}
-		} else if (isNotFound$1(read.reason)) {
-			out[type] = null;
-			notes.push(`No published ${origin} ${type}; taiga_list_product_documents shows what the product has.`);
-		} else throw read.reason;
-	});
-	return {
-		...out,
-		notes
-	};
-}
-/** Every published policy with its section count, so the model knows which one to read with taiga_get_document. */
-async function policiesPart(client) {
-	return (await client.listTenantDocuments({ limit: 100 })).data.filter((row) => POLICY_TYPES.includes(String(row["type"])) && row["isDraft"] === false).map((row) => ({
-		type: row["type"],
-		name: row["name"],
-		version: row["version"],
-		sections: Object.keys(sectionsOf(row["data"] ?? {}) ?? {}).length
-	}));
+/** Pages read for the summary; past this it says it counted only those. */
+const SUMMARY_PAGE = 100;
+const SETUP_TASK_FIELDS = [
+	"id",
+	"productId",
+	"productName",
+	"category",
+	"phase",
+	"target",
+	"key",
+	"isSecret",
+	"title",
+	"providerDocUrl",
+	"providerActionUrl",
+	"inboxItemId",
+	"inboxItemStatus",
+	"createdAt"
+];
+/** The API's count across every page, on the first page; nothing from an API that does not send one. */
+function totalOf(result) {
+	return typeof result.totalCount === "number" ? { totalCount: result.totalCount } : {};
 }
-/** The statuses an item is open in; the API's filter takes one at a time. */
-const OPEN_BACKLOG_STATUSES = ["backlog", "in_progress"];
 /**
-* The items still open: one status-filtered read per open status (the API
-* leaves archived items out), each paged in full up to a cap the result
-* reports. The list is oldest first and the open items are the newest, so a
-* single page would miss exactly the ones that matter. Rows carrying a
-* retired status (readable for a rolling deploy) match neither filter;
-* the settled check below keeps the shape honest for whatever comes back.
+* 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.
 */
-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, {
-				status,
-				limit: 100,
-				cursor
-			});
-			for (const row of result.data) if (!isSettledOrArchived({
-				status: String(row.status),
-				archivedAt: row.archivedAt ?? null
-			})) open.set(String(row.id), row);
-			if (!result.nextCursor) break;
-			cursor = result.nextCursor;
+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)];
 	}
-	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: 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_initiatives pages the rest." } : {}
-	};
-}
-/**
-* The linked repositories. The route serves one page of 100 and takes no
-* cursor, so past that the bundle says the list is cut rather than complete.
-*/
-async function repositoriesPart(links) {
-	const result = await links();
-	return {
-		items: pickFields(result.data, REPOSITORY_SUMMARY_FIELDS),
-		truncated: result.nextCursor !== null
-	};
-}
-async function buildsPart(client, productId) {
-	const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data;
-	const states = await initiativeStates(client, rows);
-	return pickFields(rows, CONTEXT_BUILD_FIELDS).map(readableRow).map((row) => withInitiativeState(row, states));
-}
-/**
-* 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." }
-	};
+	return out;
 }
-/** Where the product stands against the policies, as counts; taiga_get_policy_standing has each violation. */
-async function standingPart(client, productId) {
-	const standing = (await client.getPolicyStanding(productId)).data;
-	const summary = standingSummary(standing);
-	const state = standing.assessment?.state;
+/** A page of folded rows, saying how many records it folded so totalCount (records) and the rows reconcile. */
+function folded(rows, nextCursor, records) {
 	return {
-		openViolations: summary.violations,
-		bySeverity: summary.bySeverity,
-		controlsViolated: summary.controls,
-		...state === "never" || state === "failed" ? { note: `The assessment ${state === "never" ? "has never run" : "failed"}: no violations here is not an all-clear.` } : {}
-	};
-}
-async function productContext(client, product, options) {
-	const productId = product.id;
-	const granted = (part) => client.hasCapability(PARTS[part]);
-	const notGranted = Object.keys(PARTS).filter((part) => !granted(part));
-	let linksRead;
-	const links = () => linksRead ??= client.listProductRepositories(productId);
-	const fetchers = {
-		factory: () => factoryPart(client, String(product.factoryId)),
-		documents: () => documentsPart(client, product, options.documents),
-		policies: () => policiesPart(client),
-		initiatives: () => backlogPart(client, productId),
-		repositories: () => repositoriesPart(links),
-		runs: () => buildsPart(client, productId),
-		actionRequired: () => attentionPart(client, productId),
-		maintenance: () => maintenancePart(client, productId),
-		policyStanding: () => standingPart(client, productId)
-	};
-	const parts = Object.keys(fetchers).filter(granted);
-	const [settled, readiness] = await Promise.all([Promise.allSettled(parts.map((part) => fetchers[part]())), setupReadiness(client, product, links)]);
-	const bundle = { product: {
-		...pickFields([product], PRODUCT_SUMMARY_FIELDS)[0],
-		projectType: isImportedProduct(product) ? "brownfield" : "greenfield",
-		defaultOrigin: defaultOriginFor(product),
-		...readiness ? { readiness } : {}
-	} };
-	const unavailable = {};
-	parts.forEach((part, index) => {
-		const result = settled[index];
-		if (result.status === "fulfilled") bundle[part] = result.value;
-		else if (isApiFailure$1(result.reason)) unavailable[part] = unavailableReason(result.reason);
-		else throw result.reason;
-	});
-	const result = {
-		...bundle,
-		notGranted: notGranted.map((part) => `${part} (needs ${PARTS[part]})`),
-		unavailable,
-		readNext: "Read a policy with taiga_get_document (sections: [] for its outline, or a control id such as SEC-5.1), 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."
+		...page(rows, nextCursor),
+		...rows.length < records ? { recordsOnPage: records } : {}
 	};
-	let characters = JSON.stringify(inProductWords(result), null, 2).length;
-	for (let measured = -1; measured !== characters;) {
-		measured = characters;
-		characters = JSON.stringify(inProductWords({
-			...result,
-			characters: measured
-		}), null, 2).length;
-	}
-	return toolResult({
-		...result,
-		characters
-	});
 }
-function registerContextTools(server, client) {
+function registerInboxTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
-	server.registerTool("taiga_get_product_context", {
-		title: "Get product context",
-		description: `Read where a product stands in one call; the first read for any product question. Name it by ID, slug or git remote URL. Returns product (in setup, readiness and next move), factory with its instructions, specification and architecture outlines (section ids, sizes), policies with section counts, open initiatives (taiga_list_initiatives status: 'all' has the done and canceled), repositories, the latest ten runs, and counts for Action Required, open findings and policy violations. A part that failed is under unavailable, one the key cannot read under notGranted; neither shows as empty. documents: budget returns whole sections up to about ${DOCUMENT_BUDGET / 1e3}k characters each, full returns all.`,
+	server.registerTool("taiga_list_action_required", {
+		title: "List what needs a person",
+		description: "List what waits on a person (Action Required), across every product the key can open or one; the list is the team's. Reviews (plans, initiative sets, documents, pull requests, findings, policy violations) and setup only a person can do (secrets, variables, accounts, permissions). The first page opens with summary (open items by product and kind; stale ones apart) and totalCount. Rows carry waitingDays, readWith (the read that opens the subject), summary (its opening paragraph, up to 200 characters; none on a pull request review, whose title says it) and, for a pull request, prUrl; status and blocking appear when not open or when blocking; a review that no longer stands is marked stale. category: gate or setup; resolved: true reads the archive; snoozed items are hidden (snoozedHidden); full: true adds metadata. Unlike taiga_list_setup_tasks, which says 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, full, ...rest } = params;
+		const query = {
+			...rest,
+			...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 due_ = (row) => isDue(row, now);
+		const rows = result.data;
+		const due = rows.filter(due_);
+		const hidden = rows.length - due.length;
+		const overviewDue = overview ? overview.data.filter(due_) : [];
+		const checked = resolved ? {
+			stale: /* @__PURE__ */ new Map(),
+			unchecked: 0
+		} : await staleReviews(client, [...due, ...overviewDue]);
+		const stale = checked.stale;
+		return toolResult({
+			...overview ? {
+				summary: summaryOf(overviewDue, stale),
+				...overview.nextCursor ? { summaryNote: `The summary counts the first ${SUMMARY_PAGE} items.` } : {}
+			} : {},
+			...page(due.map((row) => {
+				const item = itemRow(row, now, full === true, client.hasCapability("backlog:read"));
+				const why = stale.get(String(row["id"]));
+				return why ? {
+					...item,
+					stale: why
+				} : item;
+			}), result.nextCursor),
+			...totalOf(result),
+			...hidden > 0 ? { snoozedHidden: hidden } : {},
+			...checked.unchecked > 0 ? { staleNote: `${checked.unchecked} review${checked.unchecked === 1 ? " was" : "s were"} not checked for staleness (past the cap, or the read was refused).` } : {}
+		});
+	}));
+	server.registerTool("taiga_list_setup_tasks", {
+		title: "List setup tasks",
+		description: "List what a person must set up for a product (secrets, variables, accounts), with exactly what and where: key (the name to create; Taiga never stores values), the provider page, and phase: prereq (the deploy fails without it), wiring (generated values back to providers) or followup (can wait until after launch). Runs do not wait for them. One product or all, oldest first; includeDone: true adds done and dismissed. A variable filed twice lists the others under alsoFiledAs; totalCount counts records, and a page that folded some says recordsOnPage. Unlike taiga_list_action_required, which lists the same work as items to resolve.",
 		inputSchema: z.object({
 			productId: productId.optional(),
-			slug: slug.optional(),
-			remoteUrl: remoteUrl.optional(),
-			documents: z.enum(DOCUMENT_DEPTHS).optional().describe("The specification and architecture as outline (section ids and sizes, the default), budget (the whole sections that fit) or full")
+			includeDone: z.boolean().optional().describe("Also the tasks already done or dismissed (default false)"),
+			...pagination
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const resolved = await resolveProductRef(client, params, [
-			"productId",
-			"slug",
-			"remoteUrl"
-		]);
-		if ("refusal" in resolved) return toolError(resolved.refusal.code, resolved.refusal.message);
-		return productContext(client, resolved.product, { documents: params.documents ?? "outline" });
-	}));
-}
-//#endregion
-//#region src/tools/autonomy.ts
-/**
-* Autonomy (docs.tai.ga, Deliver: Initiatives, Auto-merge): whether a landed
-* plan is built without a review, and whether a pull request merges on its
-* own. The organization and its factories are ceilings for merging, set by
-* an administrator in the web; a product sets defaults; an initiative's own
-* switch is the final word within the ceilings. The initiative's build gate
-* is taiga_set_auto_build.
-*/
-function registerAutonomyTools(server, client) {
-	if (client.hasCapability("products:write")) server.registerTool("taiga_set_product_autonomy", {
-		title: "Set a product's autonomy defaults",
-		description: "Set the defaults a product's initiatives follow unless they decide for themselves. autoBuild: false makes every plan wait for a person to approve or reject it; true builds it as soon as the product has room. autoMerge: false makes pull requests wait for a person to merge; null follows the organization and factory (autonomous merge needs the organization switch on, a factory can turn it off, and neither is changed here).",
-		inputSchema: z.object({
-			productId,
-			autoBuild: z.boolean().optional().describe("Build landed plans without a review by default"),
-			autoMerge: z.boolean().nullable().optional().describe("false: pull requests wait for a person by default; null: follow the organization and factory")
-		}),
-		annotations: OPERATE_SETTING
-	}, (params) => runTool(async () => {
-		if (params.autoBuild === void 0 && params.autoMerge === void 0) return toolError("VALIDATION_ERROR", "Set autoBuild, autoMerge or both.");
-		const autoMerge = params.autoMerge === true ? null : params.autoMerge;
-		const product = (await client.updateProduct(params.productId, {
-			...params.autoBuild !== void 0 ? { autoBuild: params.autoBuild } : {},
-			...autoMerge !== void 0 ? { autoMerge } : {}
-		})).data;
-		return toolResult(pickFields([product], [
-			"id",
-			"name",
-			"slug",
-			"autoBuild",
-			"autoMerge"
-		])[0]);
+		const { includeDone, ...rest } = params;
+		const result = await client.listSetupTasks({
+			...rest,
+			...includeDone ? {} : { openOnly: true },
+			...params.cursor === void 0 ? { withTotal: true } : {}
+		});
+		return toolResult({
+			...folded(sameKeyOnce(pickFields(result.data, SETUP_TASK_FIELDS)), result.nextCursor, result.data.length),
+			...totalOf(result)
+		});
 	}));
-	if (client.hasCapability("backlog:write")) server.registerTool("taiga_set_auto_merge", {
-		title: "Set whether an initiative's pull request merges on its own",
-		description: "Set whether one initiative's pull request merges itself once the repository's rules pass (required checks, reviews, a code reviewer Taiga waits for): true, false (a person merges), or null (product default). Where the organization or factory has turned autonomous merge off, true changes nothing. Taiga merges through the repository's rules, never around them.",
+	if (!client.hasCapability("products:write")) return;
+	server.registerTool("taiga_resolve_action", {
+		title: "Resolve or snooze an Action Required item",
+		description: "Set an Action Required item for everybody: done, dismissed (does not apply), in_progress, or snooze it until a time (null wakes it). Resolving a review approves or merges nothing; answer the plan or pull request where it lives. Marking the product documents review done records, in your name, that every published document was reviewed (in_progress withdraws it): only when the person says they read them. Ask before clearing what the person has not dealt with.",
 		inputSchema: z.object({
-			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")
+			actionId: idInput("Action Required item", "taiga_list_action_required gives it"),
+			status: z.enum([
+				"in_progress",
+				"done",
+				"dismissed"
+			]).optional().describe("What became of it"),
+			snoozedUntil: z.string().datetime().nullable().optional().describe("Hide it until this time (ISO 8601 in UTC, ending in Z); null wakes it now")
 		}),
-		annotations: OPERATE_SETTING
+		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		const item = (await client.updateBacklogItem(params.initiativeId, { autoMerge: params.autoMerge })).data;
-		return toolResult(pickFields([item], [
-			"id",
-			"title",
-			"state",
-			"autoMerge",
-			"autoBuild"
-		])[0]);
+		if (params.status === void 0 && params.snoozedUntil === void 0) return toolError("VALIDATION_ERROR", "Say what became of the item (status) or until when to snooze it.");
+		return toolResult(pickFields([(await client.updateInboxItem(params.actionId, {
+			...params.status !== void 0 ? { status: params.status } : {},
+			...params.snoozedUntil !== void 0 ? { snoozedUntil: params.snoozedUntil } : {}
+		})).data], ITEM_FIELDS)[0]);
 	}));
 }
 //#endregion
-//#region src/tools/inbox.ts
+//#region src/tools/context.ts
 /**
-* An item as a row: what it is, whose product, how long it has waited. Not
-* its metadata by default: a document decision carried its whole text there,
-* and fifty rows came to 57 KB (PRO-2800); full: true brings it.
+* One call at the start of a coding session: everything the model would
+* otherwise collect in eight, fanned out here. Each part stands on its own
+* (Promise.allSettled): a part the API refuses or fails is named under
+* `unavailable` with what the API said, a part the key's capabilities do not
+* cover is named under `notGranted`, and neither is ever shown as empty. A
+* failure that is not the API's (a bug in this code) is not downgraded; it
+* fails the call so it surfaces.
 */
-const ITEM_FIELDS = [
+/** The two documents a coding session starts from; the rest are a read away. */
+const CONTEXT_DOCUMENT_TYPES = ["specification", "architecture"];
+const REPOSITORY_SUMMARY_FIELDS = [
 	"id",
-	"productId",
-	"productName",
-	"category",
-	"kind",
-	"subjectType",
-	"subjectId",
-	"title",
-	"summary",
+	"provider",
+	"repositoryName",
+	"repositoryUrl",
+	"effectiveBranch",
+	"isManaged"
+];
+/** 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_run has the rest. */
+const CONTEXT_BUILD_FIELDS = [
+	"id",
+	"runNumber",
+	"backlogItemId",
+	"targetTitle",
 	"status",
-	"blocking",
-	"snoozedUntil",
-	"createdAt",
-	"resolvedAt"
+	"failedReason",
+	"completedSteps",
+	"totalSteps",
+	"baseBranch",
+	"prNumber",
+	"prUrl",
+	"prState",
+	"prMerged",
+	"prDraft",
+	"reviewEscalation",
+	"error",
+	"createdAt"
 ];
-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;
-	const { summary, ...lean } = rest;
+/**
+* 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 {
-		...row["kind"] === "review_pr" && !full ? lean : {
-			...lean,
-			summary
+		doc: {
+			...doc,
+			data: {
+				...doc.data,
+				sections: kept
+			}
 		},
-		...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"] } : {}
+		dropped
 	};
 }
-/**
-* What is open, counted by product and kind: the answer to "what needs attention" without reading every row. An item
-* that no longer stands is counted under stale, not open or byKind, so nobody subtracts by hand (PRO-2800).
-*/
-function summaryOf(rows, stale) {
-	const byProduct = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const key = String(row["productId"]);
-		const entry = byProduct.get(key) ?? (row["productName"] ? {
-			productId: key,
-			product: row["productName"],
-			open: 0,
-			byKind: {}
-		} : {
-			productId: key,
-			open: 0,
-			byKind: {}
-		});
-		if (stale.has(String(row["id"]))) entry.stale = (entry.stale ?? 0) + 1;
-		else {
-			entry.open += 1;
-			entry.byKind[String(row["kind"])] = (entry.byKind[String(row["kind"])] ?? 0) + 1;
-		}
-		byProduct.set(key, entry);
+/**
+* How much of the two documents the bundle carries. The outline by default
+* (PRO-2778): the whole sections that fit a budget made the opening read run
+* to 43k characters for an active product, most of it prose a "where does it
+* stand" question never reads.
+*/
+const DOCUMENT_DEPTHS = [
+	"outline",
+	"budget",
+	"full"
+];
+/** 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_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;
+const PARTS = {
+	factory: "factories:read",
+	documents: "products:read",
+	policies: "tenant:documents:read",
+	initiatives: "backlog:read",
+	repositories: "products:read",
+	runs: "products:read",
+	actionRequired: "products:read",
+	maintenance: "products:read",
+	policyStanding: "products:read"
+};
+/** What the API said when a part failed, in the words the bundle reports. */
+function unavailableReason(reason) {
+	if (reason instanceof TaigaApiError) return apiFailureText(reason);
+	return `the API could not be reached: ${networkFailureDetail(reason)}`;
+}
+/** Whether a failed part is the API's doing; anything else is ours and propagates. */
+function isApiFailure$1(reason) {
+	return reason instanceof TaigaApiError || isNetworkFailure(reason);
+}
+function isNotFound$1(reason) {
+	return reason instanceof TaigaApiError && reason.status === 404;
+}
+/** The factory's standing guidance in full; null, with a note, when none is published or it is not section-shaped. */
+async function factoryPart(client, factoryId) {
+	const factory = (await client.getFactory(factoryId)).data;
+	const base = {
+		id: factory.id,
+		name: factory.name,
+		slug: factory.slug
+	};
+	try {
+		const doc = (await client.getFactoryDocument(factoryId, "factory_instructions")).data;
+		const sections = sectionsOf(doc.data);
+		if (!sections) return {
+			...base,
+			instructions: null,
+			instructionsVersion: doc.version,
+			note: "The published instructions are not made of sections; read them with taiga_get_factory_document."
+		};
+		return {
+			...base,
+			instructions: instructionsText(sections),
+			instructionsVersion: doc.version
+		};
+	} catch (error) {
+		if (!isNotFound$1(error)) throw error;
+		return {
+			...base,
+			instructions: null,
+			instructionsVersion: null,
+			note: "This factory has not published instructions yet."
+		};
 	}
-	return [...byProduct.values()].sort((a, b) => b.open - a.open);
 }
-/** Pull request reviews checked against their run and initiative; past this a row is left as it is. */
-const STALE_CHECKS = 10;
 /**
-* Which "Review & merge" items no longer stand, and why (PRO-2800): the run's
-* pull request closed or merged, or its initiative was canceled or finished
-* without it. Two reviewing agents counted such leftovers as live gates; the
-* row still is open in Action Required, so this says what it is now rather
-* than hiding it. Best effort, a handful of runs: a failed read leaves the
-* row as it was.
+* The specification and architecture from the product's own timeline: their
+* outline by default, the whole sections up to a budget or in full when
+* asked. Null, with a note, where unpublished.
 */
-async function staleReviews(client, rows) {
-	const byId = new Map(rows.filter((row) => row["kind"] === "review_pr" && row["subjectType"] === "build_run").map((row) => [String(row["id"]), row]));
-	const candidates = [...byId.values()].slice(0, STALE_CHECKS);
-	let unchecked = byId.size - candidates.length;
-	const out = /* @__PURE__ */ new Map();
-	await Promise.all(candidates.map(async (row) => {
-		try {
-			const run = (await client.getBuildRun(String(row["subjectId"]))).data;
-			if (run["prMerged"] === true) return void out.set(String(row["id"]), "its pull request has merged");
-			if (run["prState"] === "closed") return void out.set(String(row["id"]), "its pull request was closed");
-			if (typeof run["backlogItemId"] !== "string") return;
-			if (!client.hasCapability("backlog:read")) return void (unchecked += 1);
-			const item = (await client.getBacklogItem(run["backlogItemId"])).data;
-			if (item["state"] === "canceled" || item["status"] === "canceled") out.set(String(row["id"]), "its initiative was canceled; the pull request is still open on the forge");
-			else if (item["state"] === "done" || item["status"] === "done") out.set(String(row["id"]), "its initiative is done; this run is not the one that landed it");
-		} catch (error) {
-			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
-			unchecked += 1;
-		}
-	}));
-	unchecked += await staleBacklogReviews(client, rows, out);
+async function documentsPart(client, product, depth) {
+	const productId = product.id;
+	const origin = defaultOriginFor(product);
+	const reads = await Promise.allSettled(CONTEXT_DOCUMENT_TYPES.map((type) => client.getProductDocument(productId, type, origin)));
+	const out = { origin };
+	const notes = [];
+	CONTEXT_DOCUMENT_TYPES.forEach((type, index) => {
+		const read = reads[index];
+		if (read.status === "fulfilled") {
+			const doc = stripProvenance(read.value.data);
+			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) {
+					const outline = Object.keys(sections).map((id) => ({
+						id,
+						characters: sectionContent(sections, id)?.length ?? 0
+					}));
+					out[type] = {
+						version: doc.version,
+						sections: outline
+					};
+				} else {
+					out[type] = {
+						version: doc.version,
+						sections: null
+					};
+					notes.push(`The ${origin} ${type} is not made of sections; read it with taiga_get_product_document.`);
+				}
+			}
+		} else if (isNotFound$1(read.reason)) {
+			out[type] = null;
+			notes.push(`No published ${origin} ${type}; taiga_list_product_documents shows what the product has.`);
+		} else throw read.reason;
+	});
 	return {
-		stale: out,
-		unchecked
+		...out,
+		notes
 	};
 }
-/**
-* "Review Initiatives" items whose product has no open initiative left (PRO-2800): two reviews found one
-* waiting 15 days on a product whose initiatives had all moved on, with nothing an agent could act on. Best effort,
-* a handful of products; returns how many could not be checked.
-*/
-async function staleBacklogReviews(client, rows, out) {
-	const asks = [...new Map(rows.filter((row) => row["kind"] === "review_backlog" && typeof row["productId"] === "string").map((row) => [String(row["id"]), row])).values()];
-	if (asks.length === 0) return 0;
-	if (!client.hasCapability("backlog:read")) return asks.length;
-	const checked = [...new Set(asks.map((row) => String(row["productId"])))].slice(0, STALE_CHECKS);
-	let unchecked = asks.filter((row) => !checked.includes(String(row["productId"]))).length;
-	const empty = /* @__PURE__ */ new Set();
-	await Promise.all(checked.map(async (productId) => {
-		try {
-			const [waiting, started] = await Promise.all([client.listBacklogItems(productId, {
-				status: "backlog",
-				limit: 1
-			}), client.listBacklogItems(productId, {
-				status: "in_progress",
-				limit: 1
-			})]);
-			if (waiting.data.length === 0 && started.data.length === 0) empty.add(productId);
-		} catch (error) {
-			if (!(error instanceof TaigaApiError || isNetworkFailure(error))) throw error;
-			unchecked += asks.filter((row) => row["productId"] === productId).length;
-		}
+/** Every published policy with its section count, so the model knows which one to read with taiga_get_document. */
+async function policiesPart(client) {
+	return (await client.listTenantDocuments({ limit: 100 })).data.filter((row) => POLICY_TYPES.includes(String(row["type"])) && row["isDraft"] === false).map((row) => ({
+		type: row["type"],
+		name: row["name"],
+		version: row["version"],
+		sections: Object.keys(sectionsOf(row["data"] ?? {}) ?? {}).length
 	}));
-	for (const row of asks) if (empty.has(String(row["productId"]))) out.set(String(row["id"]), "no initiative is open now: the ones it asked about are all done or canceled");
-	return unchecked;
-}
-/** Pages read for the summary; past this it says it counted only those. */
-const SUMMARY_PAGE = 100;
-const SETUP_TASK_FIELDS = [
-	"id",
-	"productId",
-	"productName",
-	"category",
-	"phase",
-	"target",
-	"key",
-	"isSecret",
-	"title",
-	"providerDocUrl",
-	"providerActionUrl",
-	"inboxItemId",
-	"inboxItemStatus",
-	"createdAt"
-];
-/** The API's count across every page, on the first page; nothing from an API that does not send one. */
-function totalOf(result) {
-	return typeof result.totalCount === "number" ? { totalCount: result.totalCount } : {};
 }
+/** The statuses an item is open in; the API's filter takes one at a time. */
+const OPEN_BACKLOG_STATUSES = ["backlog", "in_progress"];
 /**
-* 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.
+* The items still open: one status-filtered read per open status (the API
+* leaves archived items out), each paged in full up to a cap the result
+* reports. The list is oldest first and the open items are the newest, so a
+* single page would miss exactly the ones that matter. Rows carrying a
+* retired status (readable for a rolling deploy) match neither filter;
+* the settled check below keeps the shape honest for whatever comes back.
 */
-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)];
+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, {
+				status,
+				limit: 100,
+				cursor
+			});
+			for (const row of result.data) if (!isSettledOrArchived({
+				status: String(row.status),
+				archivedAt: row.archivedAt ?? null
+			})) open.set(String(row.id), row);
+			if (!result.nextCursor) break;
+			cursor = result.nextCursor;
+		}
 	}
-	return out;
+	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;
+	const byColumn = {
+		backlog: 0,
+		todo: 0,
+		queue: 0,
+		plan: 0,
+		build: 0
+	};
+	for (const row of rows) if (row.state) byColumn[row.state] = (byColumn[row.state] ?? 0) + 1;
+	return {
+		byColumn,
+		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 and byColumn counts only those read; taiga_list_initiatives pages the rest." } : {}
+	};
 }
-/** A page of folded rows, saying how many records it folded so totalCount (records) and the rows reconcile. */
-function folded(rows, nextCursor, records) {
+/**
+* The linked repositories. The route serves one page of 100 and takes no
+* cursor, so past that the bundle says the list is cut rather than complete.
+*/
+async function repositoriesPart(links) {
+	const result = await links();
 	return {
-		...page(rows, nextCursor),
-		...rows.length < records ? { recordsOnPage: records } : {}
+		items: pickFields(result.data, REPOSITORY_SUMMARY_FIELDS),
+		truncated: result.nextCursor !== null
 	};
 }
-function registerInboxTools(server, client) {
+async function buildsPart(client, productId) {
+	const rows = (await client.listBuildRuns(productId, { limit: BUILDS_IN_CONTEXT })).data;
+	const states = await initiativeStates(client, rows);
+	return pickFields(rows, CONTEXT_BUILD_FIELDS).map(readableRow).map((row) => withInitiativeState(row, states));
+}
+/**
+* What waits on a person for this product, counted as taiga_list_action_required's summary counts it (PRO-2800):
+* the reviewing agent called four tools to answer "how does it stand", and two later reviews found this count and
+* the list's disagree (18 open here, 16 there), because this one counted stale reviews and put-off items as open.
+*/
+async function attentionPart(client, productId) {
+	const result = await client.listInbox({
+		productId,
+		limit: 100
+	});
+	return {
+		...await attentionCounts(client, result.data),
+		...result.nextCursor ? { note: "These count the first 100 items; 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 standing = (await client.getPolicyStanding(productId)).data;
+	const summary = standingSummary(standing);
+	const state = standing.assessment?.state;
+	return {
+		openViolations: summary.violations,
+		bySeverity: summary.bySeverity,
+		controlsViolated: summary.controls,
+		...state === "never" || state === "failed" ? { note: `The assessment ${state === "never" ? "has never run" : "failed"}: no violations here is not an all-clear.` } : {}
+	};
+}
+async function productContext(client, product, options) {
+	const productId = product.id;
+	const granted = (part) => client.hasCapability(PARTS[part]);
+	const notGranted = Object.keys(PARTS).filter((part) => !granted(part));
+	let linksRead;
+	const links = () => linksRead ??= client.listProductRepositories(productId);
+	const fetchers = {
+		factory: () => factoryPart(client, String(product.factoryId)),
+		documents: () => documentsPart(client, product, options.documents),
+		policies: () => policiesPart(client),
+		initiatives: () => backlogPart(client, productId),
+		repositories: () => repositoriesPart(links),
+		runs: () => buildsPart(client, productId),
+		actionRequired: () => attentionPart(client, productId),
+		maintenance: () => maintenancePart(client, productId),
+		policyStanding: () => standingPart(client, productId)
+	};
+	const parts = Object.keys(fetchers).filter(granted);
+	const [settled, readiness] = await Promise.all([Promise.allSettled(parts.map((part) => fetchers[part]())), setupReadiness(client, product, links)]);
+	const bundle = { product: {
+		...pickFields([product], PRODUCT_SUMMARY_FIELDS)[0],
+		projectType: isImportedProduct(product) ? "brownfield" : "greenfield",
+		defaultOrigin: defaultOriginFor(product),
+		...readiness ? { readiness } : {}
+	} };
+	const unavailable = {};
+	parts.forEach((part, index) => {
+		const result = settled[index];
+		if (result.status === "fulfilled") bundle[part] = result.value;
+		else if (isApiFailure$1(result.reason)) unavailable[part] = unavailableReason(result.reason);
+		else throw result.reason;
+	});
+	const result = {
+		...bundle,
+		notGranted: notGranted.map((part) => `${part} (needs ${PARTS[part]})`),
+		unavailable,
+		readNext: "Read a policy with taiga_get_document (sections: [] for its outline, or a control id such as SEC-5.1), 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(inProductWords(result), null, 2).length;
+	for (let measured = -1; measured !== characters;) {
+		measured = characters;
+		characters = JSON.stringify(inProductWords({
+			...result,
+			characters: measured
+		}), null, 2).length;
+	}
+	return toolResult({
+		...result,
+		characters
+	});
+}
+function registerContextTools(server, client) {
 	if (!client.hasCapability("products:read")) return;
-	server.registerTool("taiga_list_action_required", {
-		title: "List what needs a person",
-		description: "List what waits on a person (Action Required), across every product the key can open or one; the list is the team's. Reviews (plans, initiative sets, documents, pull requests, findings, policy violations) and setup only a person can do (secrets, variables, accounts, permissions). The first page opens with summary (open items by product and kind) and totalCount. Rows carry waitingDays and, for a pull request, prUrl; a review that no longer stands is marked stale. category: gate or setup; resolved: true reads the archive; snoozed items are hidden (snoozedHidden); full: true adds metadata. Unlike taiga_list_setup_tasks, which says exactly what to set and where.",
+	server.registerTool("taiga_get_product_context", {
+		title: "Get product context",
+		description: `Read where a product stands in one call; the first read for any product question. Name it by ID, slug or git remote URL. Returns product (in setup, readiness and next move), factory with its instructions, specification and architecture outlines (section ids, sizes), policies with section counts, open initiatives with a count per board column (byColumn; taiga_list_initiatives status: 'all' has the done and canceled), repositories, the latest ten runs, and counts for Action Required, open findings and policy violations. A part that failed is under unavailable, one the key cannot read under notGranted; neither shows as empty. documents: budget returns whole sections up to about ${DOCUMENT_BUDGET / 1e3}k characters each, full returns all.`,
 		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
+			slug: slug.optional(),
+			remoteUrl: remoteUrl.optional(),
+			documents: z.enum(DOCUMENT_DEPTHS).optional().describe("The specification and architecture as outline (section ids and sizes, the default), budget (the whole sections that fit) or full")
 		}),
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
-		const { resolved, full, ...rest } = params;
-		const query = {
-			...rest,
-			...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(isDue);
-		const hidden = rows.length - due.length;
-		const overviewDue = overview ? overview.data.filter(isDue) : [];
-		const checked = resolved ? {
-			stale: /* @__PURE__ */ new Map(),
-			unchecked: 0
-		} : await staleReviews(client, [...due, ...overviewDue]);
-		const stale = checked.stale;
-		return toolResult({
-			...overview ? {
-				summary: summaryOf(overviewDue, stale),
-				...overview.nextCursor ? { summaryNote: `The summary counts the first ${SUMMARY_PAGE} items.` } : {}
-			} : {},
-			...page(due.map((row) => {
-				const item = itemRow(row, now, full === true);
-				const why = stale.get(String(row["id"]));
-				return why ? {
-					...item,
-					stale: why
-				} : item;
-			}), result.nextCursor),
-			...totalOf(result),
-			...hidden > 0 ? { snoozedHidden: hidden } : {},
-			...checked.unchecked > 0 ? { staleNote: `${checked.unchecked} review${checked.unchecked === 1 ? " was" : "s were"} not checked for staleness (past the cap, or the read was refused).` } : {}
-		});
+		const resolved = await resolveProductRef(client, params, [
+			"productId",
+			"slug",
+			"remoteUrl"
+		]);
+		if ("refusal" in resolved) return toolError(resolved.refusal.code, resolved.refusal.message);
+		return productContext(client, resolved.product, { documents: params.documents ?? "outline" });
 	}));
-	server.registerTool("taiga_list_setup_tasks", {
-		title: "List setup tasks",
-		description: "List what a person must set up for a product (secrets, variables, accounts), with exactly what and where: key (the name to create; Taiga never stores values), the provider page, and phase: prereq (the deploy fails without it), wiring (generated values back to providers) or followup (can wait until after launch). Runs do not wait for them. One product or all, oldest first; includeDone: true adds done and dismissed. A variable filed twice lists the others under alsoFiledAs; totalCount counts records, and a page that folded some says recordsOnPage. Unlike taiga_list_action_required, which lists the same work as items to resolve.",
+}
+//#endregion
+//#region src/tools/autonomy.ts
+/**
+* Autonomy (docs.tai.ga, Deliver: Initiatives, Auto-merge): whether a landed
+* plan is built without a review, and whether a pull request merges on its
+* own. The organization and its factories are ceilings for merging, set by
+* an administrator in the web; a product sets defaults; an initiative's own
+* switch is the final word within the ceilings. The initiative's build gate
+* is taiga_set_auto_build.
+*/
+function registerAutonomyTools(server, client) {
+	if (client.hasCapability("products:write")) server.registerTool("taiga_set_product_autonomy", {
+		title: "Set a product's autonomy defaults",
+		description: "Set the defaults a product's initiatives follow unless they decide for themselves. autoBuild: false makes every plan wait for a person to approve or reject it; true builds it as soon as the product has room. autoMerge: false makes pull requests wait for a person to merge; null follows the organization and factory (autonomous merge needs the organization switch on, a factory can turn it off, and neither is changed here).",
 		inputSchema: z.object({
-			productId: productId.optional(),
-			includeDone: z.boolean().optional().describe("Also the tasks already done or dismissed (default false)"),
-			...pagination
+			productId,
+			autoBuild: z.boolean().optional().describe("Build landed plans without a review by default"),
+			autoMerge: z.boolean().nullable().optional().describe("false: pull requests wait for a person by default; null: follow the organization and factory")
 		}),
-		annotations: READ_ONLY
+		annotations: OPERATE_SETTING
 	}, (params) => runTool(async () => {
-		const { includeDone, ...rest } = params;
-		const result = await client.listSetupTasks({
-			...rest,
-			...includeDone ? {} : { openOnly: true },
-			...params.cursor === void 0 ? { withTotal: true } : {}
-		});
-		return toolResult({
-			...folded(sameKeyOnce(pickFields(result.data, SETUP_TASK_FIELDS)), result.nextCursor, result.data.length),
-			...totalOf(result)
-		});
+		if (params.autoBuild === void 0 && params.autoMerge === void 0) return toolError("VALIDATION_ERROR", "Set autoBuild, autoMerge or both.");
+		const autoMerge = params.autoMerge === true ? null : params.autoMerge;
+		const product = (await client.updateProduct(params.productId, {
+			...params.autoBuild !== void 0 ? { autoBuild: params.autoBuild } : {},
+			...autoMerge !== void 0 ? { autoMerge } : {}
+		})).data;
+		return toolResult(pickFields([product], [
+			"id",
+			"name",
+			"slug",
+			"autoBuild",
+			"autoMerge"
+		])[0]);
 	}));
-	if (!client.hasCapability("products:write")) return;
-	server.registerTool("taiga_resolve_action", {
-		title: "Resolve or snooze an Action Required item",
-		description: "Set an Action Required item for everybody: done, dismissed (does not apply), in_progress, or snooze it until a time (null wakes it). Resolving a review approves or merges nothing; answer the plan or pull request where it lives. Marking the product documents review done records, in your name, that every published document was reviewed (in_progress withdraws it): only when the person says they read them. Ask before clearing what the person has not dealt with.",
+	if (client.hasCapability("backlog:write")) server.registerTool("taiga_set_auto_merge", {
+		title: "Set whether an initiative's pull request merges on its own",
+		description: "Set whether one initiative's pull request merges itself once the repository's rules pass (required checks, reviews, a code reviewer Taiga waits for): true, false (a person merges), or null (product default). Where the organization or factory has turned autonomous merge off, true changes nothing. Taiga merges through the repository's rules, never around them.",
 		inputSchema: z.object({
-			actionId: idInput("Action Required item", "taiga_list_action_required gives it"),
-			status: z.enum([
-				"in_progress",
-				"done",
-				"dismissed"
-			]).optional().describe("What became of it"),
-			snoozedUntil: z.string().datetime().nullable().optional().describe("Hide it until this time (ISO 8601 in UTC, ending in Z); null wakes it now")
+			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
+		annotations: OPERATE_SETTING
 	}, (params) => runTool(async () => {
-		if (params.status === void 0 && params.snoozedUntil === void 0) return toolError("VALIDATION_ERROR", "Say what became of the item (status) or until when to snooze it.");
-		return toolResult(pickFields([(await client.updateInboxItem(params.actionId, {
-			...params.status !== void 0 ? { status: params.status } : {},
-			...params.snoozedUntil !== void 0 ? { snoozedUntil: params.snoozedUntil } : {}
-		})).data], ITEM_FIELDS)[0]);
+		const item = (await client.updateBacklogItem(params.initiativeId, { autoMerge: params.autoMerge })).data;
+		return toolResult(pickFields([item], [
+			"id",
+			"title",
+			"state",
+			"autoMerge",
+			"autoBuild"
+		])[0]);
 	}));
 }
 //#endregion
@@ -20924,7 +21066,7 @@ function registerRepositoryTools(server, client) {
 	}
 	if (client.hasCapability("vcs:read")) server.registerTool("taiga_list_linkable_repositories", {
 		title: "Find a repository to link",
-		description: "List the repositories the organization's GitHub connection can reach, to link one with taiga_link_repository (it takes the id). query searches by name; account (login, owner, or installationId) reads one account, else rows come from every account in turn. linked: true means a product already links it (taiga_get_product with its URL says which). No connection means GitHub is not connected yet; someone who can install the app does that once, in the web.",
+		description: "List the repositories the organization's GitHub connection can reach, to link one with taiga_link_repository (it takes the row's id: Taiga's record of the repository, not GitHub's numeric id, and not a link ID). query searches by name; account (login, owner, or installationId) reads one account, else rows come from every account in turn. linked: true means a product already links it (taiga_get_product with its URL says which). No connection means GitHub is not connected yet; someone who can install the app does that once, in the web.",
 		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"),
@@ -20951,7 +21093,7 @@ function registerRepositoryTools(server, client) {
 			});
 			const found = rows(result.data);
 			return toolResult({
-				accounts,
+				accounts: params.account || params.installationId ? pickFields(chosen, INSTALLATION_FIELDS) : accounts,
 				repositories: page(found.slice(0, max), result.nextCursor),
 				...found.length > max ? { more: "More matched than the limit; narrow the query or raise the limit." } : {}
 			});
@@ -20974,7 +21116,7 @@ function registerRepositoryTools(server, client) {
 		description: "Link a GitHub repository to a product (taiga_list_linkable_repositories gives its id). replacesRepositoryId swaps out the one linked now in one step (the same one changes nothing); linking while one is linked without it is refused. A managed link (isManaged) cannot be replaced or unlinked. Once linked, planning reads its code, runs open pull requests in it, sweeps scan it, and its deployment history is imported.",
 		inputSchema: z.object({
 			productId,
-			githubRepositoryId: idInput("GitHub repository", "taiga_list_linkable_repositories gives it"),
+			githubRepositoryId: idInput("GitHub repository", "taiga_list_linkable_repositories gives it (the row's id, Taiga's record; not GitHub's numeric id)"),
 			replacesRepositoryId: repositoryId.optional().describe("The link this one replaces")
 		}),
 		annotations: OPERATE
@@ -21948,30 +22090,31 @@ function registerWhoami(server, client, registered) {
 * (PRO-2800).
 */
 const SERVER_INSTRUCTIONS = [
-	"Taiga is a policy-aware software delivery platform. Use these tools (taiga_*) whenever the person asks about a",
-	"Taiga product, its initiatives or runs, policies, findings, deployments, or setting a product up.",
+	"Taiga is a policy-aware software delivery platform. Use these tools (taiga_*) when the person asks about a Taiga",
+	"product, its initiatives or runs, policies, findings, deployments, or setting a product up.",
 	"",
-	"**Which read.** Where a product stands: taiga_get_product_context (by git remote URL, slug or ID). What waits on",
-	"people: taiga_list_action_required. A policy: taiga_get_document (sections: [] for the outline, or a control id",
-	"such as SEC-5.1). Findings: taiga_list_findings. One initiative or run: taiga_get_initiative, taiga_get_run.",
-	"This key's role and which tools write: taiga_whoami.",
+	"**Which read.** Where a product stands (counts, not detail): taiga_get_product_context, by git remote URL, slug",
+	"or ID. What waits on people: taiga_list_action_required. A policy: taiga_get_document (sections: [], or a",
+	"control id such as SEC-5.1). Findings: taiga_list_findings. One initiative or run: taiga_get_initiative,",
+	"taiga_get_run. Which tools this key may call: taiga_whoami.",
 	"",
-	"**Words.** An initiative is a unit of work; its board columns are backlog, todo, queue, plan, build, done, canceled. The",
-	"line is the product's queue, worked one initiative at a time through plan and build. A run is one attempt by the",
-	"coding agent; hardening is its pass of security scans and fixes; handed back means the agent stopped and a person",
-	"must act. A factory owns products. People stamp checks in the web. IDs are UUIDs, never names; a NOT_FOUND names",
-	"the tool that lists them, and a GitHub repository id is not a repository link id.",
+	"**Words.** An initiative is a unit of work, on a board of columns (backlog, todo, queue, plan, build, done,",
+	"canceled); the plan and build columns are stations. The line works the queue one initiative at a time. A run is",
+	"one coding-agent attempt; hardening is its security pass; handed back means a person must act. A gate is a review",
+	"a person makes; a sweep is a scan for findings; standing is how a product meets the policies. Discovery is the web",
+	"conversation that specifies a new product. A factory owns products. People stamp checks in the web.",
 	"",
-	"**Reading.** Lists page with nextCursor. A document has two timelines: plan (what was meant) and reality",
-	"(derived from the code). outcome, situation and nextStep are one-sentence summaries of their record.",
+	"**IDs** are UUIDs; the product, factory and initiative lists take query to find one by name. A NOT_FOUND names the tool that lists the right",
+	"ones. Lists page with nextCursor. outcome, situation and nextStep are one-sentence summaries; setup writes",
+	"return readiness with nextStep, so there is no need to read the product again. A product document has two",
+	"timelines: plan (what was meant) and reality (derived from the code).",
 	"",
-	"**Writing.** A tool that writes opens with \"Writes.\", \"Ask first (paid agent work).\" or \"Ask first (others see",
-	"it).\"; before an ask-first tool, tell the person what you will do and wait for their yes. Others share this",
-	"organization: a taken factory name (or product name in its factory) is refused unless allowDuplicateName, and",
-	"the one that exists may not be this person's.",
+	"**Writing.** A tool that writes opens with \"Writes.\", \"Ask first (paid agent work).\" or \"Ask first (others",
+	"see it).\"; before an ask-first tool, tell the person and wait for their yes. Others share the organization: a",
+	"taken name is refused unless allowDuplicateName, and the one that exists may not be this person's.",
 	"",
-	"**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 factories and products."
+	"**Only in the web:** connecting GitHub, members and roles, Discovery, stamping checks, starting a run over, and",
+	"deleting factories and products."
 ].join("\n");
 //#endregion
 //#region src/server.ts