@taiga-ai/mcp-server 0.36.0-rc.800 → 0.36.0-rc.926

package/dist/index.js

@@ -23899,6 +23899,18 @@ var TaigaClient = class {
 	async getLicenseSummary(productId) {
 		return this.request("GET", `/products/${seg(productId)}/maintenance/licenses`);
 	}
+	/** One licence across a product's inventory (PRO-3251): what it asks, when to allow it, what brings it in. */
+	async getProductLicense(productId, license) {
+		return this.request("GET", `/products/${seg(productId)}/maintenance/licenses/detail?license=${encodeURIComponent(license)}`);
+	}
+	/** Allow a licence in one product: every licence finding in force for it there ignored (PRO-3727). */
+	async allowProductLicense(productId, body) {
+		return this.request("POST", `/products/${seg(productId)}/maintenance/licenses/ignore`, body);
+	}
+	/** Allow a licence in one product no longer: every one of its ignored licence findings there open again. */
+	async reopenProductLicense(productId, license) {
+		return this.request("POST", `/products/${seg(productId)}/maintenance/licenses/reopen`, { license });
+	}
 	/** The organization's approved list and every licence in use across its products (PRO-3311). */
 	async getOrganizationLicenses() {
 		return this.request("GET", "/tenants/current/licenses");
@@ -23926,6 +23938,10 @@ var TaigaClient = class {
 	async updateFinding(id, body) {
 		return this.request("PATCH", `/maintenance/findings/${seg(id)}`, body);
 	}
+	/** Ship notices (PRO-4165): raise the initiative that builds the product's open-source notices, or get the open one. */
+	async shipNotices(productId) {
+		return this.request("POST", `/products/${seg(productId)}/maintenance/notices`, {});
+	}
 	async remediateFinding(productId, findingId) {
 		return this.request("POST", `/products/${seg(productId)}/maintenance/findings/${seg(findingId)}/remediate`, {});
 	}
@@ -24065,7 +24081,7 @@ var TaigaClient = class {
 	async refreshRealityDocuments(productId, docTypes) {
 		return this.request("POST", `/products/${seg(productId)}/documents/refresh-reality`, docTypes ? { docTypes } : void 0);
 	}
-	/** What still blocks finishing setup: required documents unpublished, required checks unstamped (PRO-2800). */
+	/** What still blocks finishing setup: the required documents unpublished (PRO-2800). */
 	async getProductSetupBlockers(productId) {
 		return this.request("GET", `/products/${seg(productId)}/setup`);
 	}
@@ -24402,18 +24418,47 @@ const EU_COUNTRIES = [
 	}
 ];
 /**
-* EEA countries outside the EU. Norway only: Iceland and Liechtenstein have
-* no overlay and no customer asking for one.
+* EEA countries outside the EU, all three, so {@link COUNTRIES} covers the
+* whole EU and EEA (PRO-3791). Only Norway has a country layer; Iceland and
+* Liechtenstein get the `eea` region layer alone, and neither is offered as a
+* Taiga tenant country ({@link offeredCountries}).
+*/
+const EEA_COUNTRIES = [
+	{
+		code: "NO",
+		name: "Norway"
+	},
+	{
+		code: "IS",
+		name: "Iceland"
+	},
+	{
+		code: "LI",
+		name: "Liechtenstein"
+	}
+];
+/**
+* The United Kingdom (PRO-3420): ISO code `GB`, neither EU nor EEA, in the
+* `uk` region. Offered only while the `regulations` flag is on.
 */
-const EEA_COUNTRIES = [{
-	code: "NO",
-	name: "Norway"
+const UK_COUNTRIES = [{
+	code: "GB",
+	name: "United Kingdom"
 }];
-[...EU_COUNTRIES, ...EEA_COUNTRIES];
+[
+	...EU_COUNTRIES,
+	...EEA_COUNTRIES,
+	...UK_COUNTRIES
+];
 /** Countries available during closed beta. Expand as we open new markets. */
 const BETA_COUNTRIES = ["FI"];
+[...EU_COUNTRIES.map((c) => c.code).filter((code) => !BETA_COUNTRIES.includes(code))];
 EU_COUNTRIES.filter((c) => BETA_COUNTRIES.includes(c.code));
-Object.fromEntries([...EU_COUNTRIES.map((c) => [c.code, "eu"]), ...EEA_COUNTRIES.map((c) => [c.code, "eea"])]);
+Object.fromEntries([
+	...EU_COUNTRIES.map((c) => [c.code, "eu"]),
+	...EEA_COUNTRIES.map((c) => [c.code, "eea"]),
+	...UK_COUNTRIES.map((c) => [c.code, "uk"])
+]);
 //#endregion
 //#region ../../packages/types/dist/factories.js
 const FACTORY_DOCUMENT_TYPES = ["factory_instructions"];
@@ -24642,6 +24687,19 @@ const PRODUCT_DOCUMENT_DISPLAY_NAMES = {
 const PRODUCT_DOCUMENT_ORIGINS = ["plan", "reality"];
 /** The forges a repository link can name: `FORGE_PROVIDERS`, under the name links have always used. */
 const VCS_PROVIDERS = FORGE_PROVIDERS;
+Object.fromEntries(Object.entries({
+	specification: "specification",
+	"user-flows": "user_flow",
+	architecture: "architecture",
+	"tech-decisions": "technology_decisions",
+	"data-flow": "data_flow",
+	"threat-model": "threat_model",
+	dpia: "privacy_assessment",
+	"risk-register": "risk_register",
+	"service-blueprint": "service_blueprint",
+	"ui-direction": "ui_direction",
+	"codebase-snapshot": "codebase_snapshot"
+}).map(([slug, apiType]) => [apiType, slug]));
 //#endregion
 //#region ../../packages/types/dist/route-key.js
 /**
@@ -24884,7 +24942,7 @@ const HALT_CAUSES = {
 	* reaped on a dead heartbeat, or found at 'planning' with no live job by the
 	* reconciler, which fails it with that cause on the tick that notices
 	* (`armPlanning` writes the status and creates the job in ONE transaction,
-	* so that shape is never a race). One of three halts that mirror
+	* so that shape is never a race). One of four halts that mirror
 	* `PLAN_FAILURE_CAUSES` one-to-one; see `PLAN_FAILURE_HALT`.
 	*/
 	planning_stalled: {
@@ -24897,6 +24955,22 @@ const HALT_CAUSES = {
 			"remove"
 		]
 	},
+	/**
+	* The planner concluded nothing should be built (PRO-3941): a licence's
+	* replacement where only build tools carry the licence and no maintained
+	* package replaces them. Not a fault, so not `planning_failed`; its reason
+	* is the detail, read off the planning job as a failure's is.
+	*/
+	planning_declined: {
+		message: "The plan recommends not building this, so the queue stopped here.",
+		params: [],
+		clearedWhen: "planning is retried, or a re-plan replaces it",
+		exits: [
+			"auto",
+			"reorder",
+			"remove"
+		]
+	},
 	/** The run errored out. */
 	run_failed: {
 		message: "The run failed, so the queue stopped here.",
@@ -25178,7 +25252,8 @@ const READY_BLOCKERS = [
 	"bar_lowering",
 	"bar_lowering_unchecked",
 	"criticals_unresolved",
-	"clean_checkout_failed"
+	"clean_checkout_failed",
+	"license_not_approved"
 ];
 /**
 * Why the autonomous loop handed a live pull request to a person (PRO-2409).
@@ -25291,6 +25366,7 @@ const INBOX_ITEM_KINDS = [
 	"review_pr",
 	"review_maintenance",
 	"review_policy",
+	"attest_policy",
 	"setup_env_var",
 	"setup_secret",
 	"setup_third_party",
@@ -25415,6 +25491,7 @@ discriminatedUnion("kind", [
 		})).max(20),
 		moreFailed: number$1().int().min(0).optional(),
 		observedAt: optionalMoment,
+		repository: string$2().min(1).max(255).optional(),
 		stepId: optionalUuid
 	}),
 	object({
@@ -26007,6 +26084,92 @@ object({
 	...outcomes === void 0 ? {} : { outcomes }
 }));
 //#endregion
+//#region ../../packages/types/dist/registries.js
+/**
+* The package ecosystems a registry can serve: every ecosystem the coding
+* agent builds (its skills and its image), keyed by the install tooling that
+* reads the credential. `maven` is a Maven repository, and Maven builds get
+* its credential (PRO-2916); Gradle builds name theirs in their own build
+* scripts and get none yet (PRO-2928).
+*/
+const REGISTRY_ECOSYSTEMS = [
+	"npm",
+	"terraform",
+	"pypi",
+	"nuget",
+	"go",
+	"cargo",
+	"maven",
+	"rubygems",
+	"composer"
+];
+const REGISTRY_VENDORS = [
+	"npmjs",
+	"github",
+	"gcp_artifact",
+	"generic",
+	"hcp_terraform",
+	"scalr",
+	"azure_artifacts",
+	"jfrog",
+	"git_host",
+	"aws_codeartifact"
+];
+/** An IAM role ARN, as the CodeArtifact credential takes it. */
+const AWS_ROLE_ARN_PATTERN = /^arn:aws:iam::\d{12}:role\/[\w+=,.@/-]{1,512}$/;
+//#endregion
+//#region ../../packages/types/dist/gitlab.js
+/**
+* GitLab connections (PRO-3096, P-PRO-150): the shared request/response
+* contract of `/v1/gitlab/connections`. A connection is one GitLab host
+* (GitLab.com, a self-managed instance or GitLab Dedicated) with a bot token
+* the tenant pasted. The token is write-only and appears in no response.
+*/
+const GITLAB_CONNECTION_STATUSES = [
+	"valid",
+	"auth_failed",
+	"unreachable"
+];
+//#endregion
+//#region ../../packages/types/dist/cloud-connections.js
+const CLOUD_CONNECTION_STATUSES = [
+	"pending_setup",
+	"validating",
+	"active",
+	"error",
+	"suspended",
+	"disconnected"
+];
+/**
+* Keys in `providerConfig` that only Taiga's provisioning path may write.
+*
+* PRO-858. `accountName` is the correlation key the AFT account-ready callback
+* arrives with, and the webhook resolves it under service context with no
+* tenant predicate -- it has to, because the callback carries no tenant. It is
+* also guessable: `generateAccountName` derives it from tenant, team and
+* project slugs. So a tenant that could write this key could plant a row
+* claiming another tenant's account name, wait for that callback, and have the
+* victim's `deployConfig` (accountId, deployRoleArn, stateBucket) delivered to
+* their own environment.
+*
+* `accountKey` is the same identity in unguessable form
+* (`sha256(tenantId:productId:envType)`), and is what the AFT module is named
+* for -- equally not the caller's to assert.
+*
+* Neither is tenant-facing: no provider schema models them, and
+* `providerConfigProblem` documents them as the shape a MANAGED row has. The
+* update path merges and persists the RAW config precisely so Zod does not
+* strip them off managed rows, which is what made a tenant-supplied value
+* durable. Rejecting rather than stripping, so a client sending one is told,
+* instead of silently having it dropped.
+*/
+const TAIGA_MANAGED_PROVIDER_CONFIG_KEYS = ["accountName", "accountKey"];
+/** Whether `config` leaves alone the keys only Taiga's provisioning writes. */
+function isTenantWritableProviderConfig(config) {
+	return !TAIGA_MANAGED_PROVIDER_CONFIG_KEYS.some((key) => key in config);
+}
+const TAIGA_MANAGED_PROVIDER_CONFIG_MESSAGE = `providerConfig may not set ${TAIGA_MANAGED_PROVIDER_CONFIG_KEYS.join(" or ")}: Taiga's provisioning owns those keys`;
+//#endregion
 //#region ../../packages/types/dist/environments.js
 const ENVIRONMENT_TYPES = [
 	"development",
@@ -26020,6 +26183,31 @@ const ENVIRONMENT_TYPES = [
 //#endregion
 //#region ../../packages/types/dist/api-keys.js
 /**
+* API key scopes control what operations a key can perform.
+* Scopes act as a ceiling -- the effective permissions are the intersection
+* of the key's scopes and the user's role-based capabilities.
+*
+* Convention: "resource:action" matching the existing Capability type.
+*/
+const API_KEY_SCOPES = [
+	"products:read",
+	"products:write",
+	"backlog:read",
+	"backlog:write",
+	"factories:read",
+	"factories:documents:write",
+	"users:read",
+	"tenant:documents:read",
+	"tenant:documents:write",
+	"vcs:read",
+	"customDocuments:read",
+	"customDocuments:write",
+	"customDocuments:delete",
+	"factories:write",
+	"vcs:manage"
+];
+const API_KEY_PREFIX = "taiga_sk_live_";
+/**
 * The groups the MCP server's tools come in (PRO-2838). A key may name the ones
 * its AI tool sees; null is every one. This is focus, not security: a tool the
 * key's role or scopes do not allow is never offered, whatever is named here.
@@ -26031,6 +26219,11 @@ const MCP_TOOLSETS = [
 	"observe",
 	"documents"
 ];
+Object.freeze({
+	required: false,
+	gracePeriodDays: 0,
+	requiredSince: null
+});
 [...TURN_EVENT_TRIGGERS];
 /** Longest request for changes from Taiga (PRO-3035): about four pages of prose. */
 const CHANGE_REQUEST_MAX_CHARS = 1e4;
@@ -26051,6 +26244,8 @@ const REQUEST_EXITS = [
 	"dismiss",
 	"reviewed"
 ];
+/** The most ids an answer's `seen` carries; a longer list is not sent, and the review is not checked. */
+const REVIEW_SEEN_MAX = 1e4;
 //#endregion
 //#region ../../packages/types/dist/maintenance.js
 /**
@@ -26146,10 +26341,30 @@ function isFixableFinding(finding) {
 	if (finding.status !== "open") return false;
 	if (finding.location?.historyOnly) return false;
 	if (!isAgentRemediable(finding)) return false;
+	if (finding.fingerprint?.startsWith("base-image:") || finding.baseImageFix) {
+		if (finding.baseImageFix) return finding.baseImageFix.way === "move" || finding.baseImageFix.way === "upgrade";
+		return typeof finding.baseMove === "boolean" ? finding.baseMove : baseImageMoveRemoves(finding.data);
+	}
 	if (finding.kind === "vulnerable_dependency" && isMaliciousPackageFinding(finding)) return true;
+	if (isPinBlocked(finding)) return false;
 	return isCodeRemediationKind(finding.kind) || !!finding.recommendedVersion;
 }
 /**
+* Whether a Fix cannot work: another package's pin caps this finding's fix, and
+* the last fix ended still vulnerable against it (`opentelemetry-api` under
+* `aws-opentelemetry-distro`'s `==1.44.0`). Another would spend a run to meet
+* it again. Blocked with no such fix, a person's Fix still runs (AC-17): they
+* may know a way round. The gate lifts the hold when the pin moves.
+*/
+function isPinBlocked(finding) {
+	return finding.autoFixHeld?.reason === "blocked_by_dependency" && finding.autoFixHeld.fixFailed === true;
+}
+function baseImageMoveRemoves(data) {
+	const baseImage = typeof data === "object" && data !== null ? data.baseImage : null;
+	const bases = typeof baseImage === "object" && baseImage !== null ? baseImage.bases : null;
+	return Array.isArray(bases) && bases.length > 0 && bases.every((b) => typeof b === "object" && b !== null && typeof b.movesTo === "string" && b.removed === true);
+}
+/**
 * A malicious package (OSV `MAL-*`): its advisory id or one of its aliases
 * says so, or its tier is Act now with no KEV listing, which only a malware
 * advisory earns (`findingTierReason`). The id and aliases come first: a
@@ -26165,6 +26380,17 @@ function isMaliciousPackageFinding(finding) {
 	if (Array.isArray(aliases) && aliases.some(mal)) return true;
 	return finding.tier === "act_now" && finding.kevListedAt == null;
 }
+/**
+* The scanner CATEGORIES a sweep reports, in the order the agent reports them
+* (PRO-1725). Outcomes are keyed on the category, not the tool, so replacing a
+* tool in the agents' scanner manifest changes nothing here.
+*/
+const MAINTENANCE_SCANNERS = [
+	"deps",
+	"secrets",
+	"sast",
+	"iac"
+];
 new Map(Object.entries({
 	deps: [
 		"vulnerable_dependency",
@@ -26370,6 +26596,19 @@ object({
 	commit: d.commit
 }));
 /**
+* The sources whose findings no agent scanner's outcome decides (PRO-4070):
+* the API's runtime judge (PRO-3659) and base OS judge (PRO-4074), and the
+* base image reading (PRO-1728), whose findings the agent drafts but only a
+* sweep that read the images may settle.
+*/
+const MAINTENANCE_JUDGED_SOURCES = [
+	"runtime",
+	"base_os",
+	"base_image"
+];
+[...MAINTENANCE_SCANNERS, ...MAINTENANCE_JUDGED_SOURCES];
+new Set(MAINTENANCE_SCANNERS);
+/**
 * The longest licence string the package list filters by (PRO-2920). The
 * inventory keeps every expression whole whatever its length; this bounds only
 * the query string, far above any expression seen. A longer one is listed in
@@ -26377,6 +26616,200 @@ object({
 */
 const MAINTENANCE_LICENSE_FILTER_MAX = 4096;
 //#endregion
+//#region ../../packages/types/dist/maintenance-advisory.js
+/**
+* Pull the renderable advisory fields out of a finding's raw OSV `data` object.
+*
+* `data` is the scanner's raw OSV vulnerability payload (MaintenanceFindingData,
+* shape varies), so every field is read leniently: a missing or malformed key
+* yields an empty value rather than throwing. Shared by the web app's finding
+* detail and the Taiga Audit preview and report (PRO-3791), so both show the
+* same identifiers for the same finding.
+*/
+/** A non-empty string, or null: anything else the scanner wrote reads as absent. */
+const text$3 = string$2().min(1).nullable().catch(null);
+/** The non-empty strings of a list; a value that is not a list reads as none. */
+const texts = array(unknown$1()).catch([]).transform((list) => list.filter((v) => typeof v === "string" && v.length > 0));
+object({
+	type: text$3,
+	score: text$3
+});
+object({
+	type: text$3,
+	url: text$3
+});
+object({
+	aliases: texts,
+	database_specific: object({
+		cwe_ids: texts,
+		severity: text$3
+	}).nullable().catch(null),
+	severity: array(unknown$1()).catch([]),
+	references: array(unknown$1()).catch([]),
+	published: text$3,
+	modified: text$3
+});
+//#endregion
+//#region ../../packages/types/dist/finding-controls.js
+/**
+* A committed credential.
+*
+* SEC-3.4  "Secrets must never be stored in source code or logs"
+* SEC-5.1  "Secrets must be stored in an approved secrets management system"
+* SEC-5.2  "Secrets must be rotated at least annually" -- the half Taiga cannot
+*          do, and the reason the remediation initiative insists the PR say so.
+* SDLC-3.5 "Secret detection must run pre-commit and in CI pipeline"
+*/
+const SECRET_CONTROLS = [
+	"SEC-3.4",
+	"SEC-5.1",
+	"SEC-5.2",
+	"SDLC-3.5"
+];
+/**
+* A vulnerable dependency.
+*
+* SCS-2.6 "critical security patches within 7 days, others within 30 days"
+*         -- breached by a vulnerability whose fix has been out past its
+*         window, and by no other (PRO-3420). One found this morning has missed
+*         nothing; neither has one with no fixed release to move to.
+* SCS-5.2 "Critical vulnerabilities must block deployment"
+*
+* Two controls this map deliberately does NOT claim:
+* - SCS-2.5 "Transitive dependency vulnerabilities must be monitored
+*   continuously". A finding is that monitoring working, not evidence it is
+*   missing; every vulnerable dependency read as a breach of it. The sweep's
+*   own record shows it met instead (sweep-evidence.ts).
+* - Anything for an outdated dependency that is no vulnerability: SCS-2.6's
+*   rationale is "timely vulnerability remediation", and an update that fixes
+*   nothing is not a security patch.
+*/
+const DEPENDENCY_CONTROLS = ["SCS-2.6", "SCS-5.2"];
+/**
+* A package whose licence the allowlist does not satisfy (PRO-2862).
+*
+* TIC-6.2 "Open source licenses must be reviewed and approved before adoption"
+*         -- the same policy section lists the approved licences and the ones
+*         requiring review, which is where the default allowlist comes from.
+*/
+const LICENSE_CONTROLS = ["TIC-6.2"];
+/**
+* Injection and unsanitized input, whatever the sink.
+*
+* SDLC-5.1 "All user input must be validated and sanitized"
+* SEC-6.1  "All API endpoints must validate and sanitize input"
+*/
+const INJECTION_CONTROLS = ["SDLC-5.1", "SEC-6.1"];
+/**
+* Every opengrep rule Taiga ships, mapped explicitly.
+*
+* A closed set, unlike checkov's -- these rules are ours, so an exhaustive map
+* is possible and a keyword heuristic would be a worse answer to an easier
+* question. `policy-map.test.ts` reads the rule ids straight out of the YAML
+* so a new rule that lands unmapped fails the build instead of silently
+* emitting no control.
+*/
+const SAST_CONTROLS = {
+	"taiga.csharp.sql-string-concat": INJECTION_CONTROLS,
+	"taiga.go.sql-string-concat": INJECTION_CONTROLS,
+	"taiga.javascript.sql-template-concat": INJECTION_CONTROLS,
+	"taiga.python.sqli-fstring": INJECTION_CONTROLS,
+	"taiga.rust.sql-format-concat": INJECTION_CONTROLS,
+	"taiga.csharp.process-start-shell-dynamic": INJECTION_CONTROLS,
+	"taiga.go.exec-command-dynamic": INJECTION_CONTROLS,
+	"taiga.javascript.child-process-exec-dynamic": INJECTION_CONTROLS,
+	"taiga.python.os-system-dynamic": INJECTION_CONTROLS,
+	"taiga.python.subprocess-shell-true": INJECTION_CONTROLS,
+	"taiga.rust.command-shell-dynamic": INJECTION_CONTROLS,
+	"taiga.javascript.eval-dynamic": INJECTION_CONTROLS,
+	"taiga.python.eval-exec-dynamic": INJECTION_CONTROLS,
+	"taiga.javascript.dangerously-set-inner-html": INJECTION_CONTROLS,
+	"taiga.javascript.innerhtml-dynamic": INJECTION_CONTROLS,
+	"taiga.csharp.binaryformatter-deserialize": ["SDLC-5.7"],
+	"taiga.python.pickle-load-untrusted": ["SDLC-5.7"],
+	"taiga.python.yaml-load-unsafe": ["SDLC-5.7"],
+	"taiga.csharp.cert-validation-disabled": ["SEC-3.2"],
+	"taiga.go.tls-insecure-skip-verify": ["SEC-3.2"],
+	"taiga.javascript.tls-reject-unauthorized-false": ["SEC-3.2"],
+	"taiga.python.requests-verify-false": ["SEC-3.2"],
+	"taiga.rust.tls-verification-disabled": ["SEC-3.2"],
+	"taiga.javascript.jwt-verify-none": ["SDLC-5.4", "SEC-9.1"],
+	"taiga.python.flask-debug-true": ["SDLC-5.5"],
+	"taiga.go.pprof-import": ["SDLC-5.5"],
+	"taiga.csharp.weak-hash": [],
+	"taiga.go.weak-hash": [],
+	"taiga.javascript.weak-hash": [],
+	"taiga.python.weak-hash": [],
+	"taiga.rust.weak-hash": [],
+	"taiga.go.math-rand-for-secrets": [],
+	"taiga.rust.non-crypto-rng-for-secrets": []
+};
+/**
+* Checkov, matched on the check's own description.
+*
+* Checkov's rule set is open and numbers in the thousands, so an exhaustive
+* id map is not available the way it is for our own rules. These phrases are
+* matched against the check title checkov itself writes ("Ensure all data
+* stored in the RDS is securely encrypted at rest"), and they are deliberately
+* narrow: a title matching nothing yields no control, which is the safe
+* direction to be wrong in.
+*
+* Exported so `policy-map.test.ts` validates THESE ids against the registry
+* too. They are the half most likely to drift, and an id-map that only
+* validates the closed half is a claim the tests do not support.
+*/
+const IAC_PHRASES = [
+	{
+		pattern: /encrypt\w*\s+at\s+rest|at\s+rest.*encrypt|securely encrypted/i,
+		controls: ["SEC-3.1"],
+		why: "at-rest encryption"
+	},
+	{
+		pattern: /\bKMS\b|customer[- ]managed key|\bCMK\b/i,
+		controls: ["SEC-3.3"],
+		why: "key management"
+	},
+	{
+		pattern: /in\s+transit|\bTLS\b|\bSSL\b|\bHTTPS\b/i,
+		controls: ["SEC-3.2"],
+		why: "transport encryption"
+	},
+	{
+		pattern: /0\.0\.0\.0\/0|ingress from|security group/i,
+		controls: ["CLD-7.2"],
+		why: "network default-deny"
+	},
+	{
+		pattern: /public(ly)?\s+(access|read|write|expos)|public access/i,
+		controls: ["CLD-1.3"],
+		why: "public exposure"
+	},
+	{
+		pattern: /least privilege|wildcard|admin(istrator)? (policy|access)/i,
+		controls: ["SEC-2.1"],
+		why: "least privilege"
+	},
+	{
+		pattern: /backup|point[- ]in[- ]time recovery/i,
+		controls: ["OPS-4.1"],
+		why: "backup"
+	},
+	{
+		pattern: /audit log|cloudtrail|access logging|logging (is )?enabled/i,
+		controls: ["SDLC-5.8"],
+		why: "security logging"
+	}
+];
+[.../* @__PURE__ */ new Set([
+	...SECRET_CONTROLS,
+	...DEPENDENCY_CONTROLS,
+	...LICENSE_CONTROLS,
+	...Object.values(SAST_CONTROLS).flat(),
+	...IAC_PHRASES.flatMap((p) => p.controls)
+])];
+new RegExp(`^\\|\\s*(${CONTROL_ID_SOURCE})\\s*\\|\\s*(.*?)\\s*(?:\\||$)`);
+REALITY_DERIVED_DOCUMENT_TYPES.filter((t) => t !== "codebase_snapshot");
+//#endregion
 //#region ../../packages/types/dist/custom-documents.js
 /**
 * Shared types for the custom-documents feature: customer-uploaded reference
@@ -26685,6 +27118,7 @@ const uploadGrant = object({
 	expiresAt: string$2()
 });
 object({ version: number$1().int().min(1) });
+object({ documentId: string$2().uuid() });
 /** The uploads a product's move could not re-file, named while they fit the answer (PRO-3497). */
 const failedDocuments = array(object({
 	id: string$2(),
@@ -26785,6 +27219,14 @@ const cloudProviderConfig = discriminatedUnion("provider", [
 		bestPractices: cloudBestPractices
 	})
 ]);
+const newCloudConnection = strictObject({
+	name: string$2().min(1).max(150),
+	provider: _enum(CLOUD_PROVIDERS),
+	providerConfig: cloudProviderConfig
+}).refine((connection) => connection.provider === connection.providerConfig.provider, {
+	message: "connection.provider must match connection.providerConfig.provider",
+	path: ["providerConfig", "provider"]
+});
 const columnIndex = number$1().int().min(1).max(EXCEL_MAX_COLUMN);
 const sheetMap = object({
 	sheetName: string$2().min(1).max(120),
@@ -26811,18 +27253,30 @@ strictObject({
 	"replanning",
 	"after_step",
 	"after_round",
-	"held"
-]).optional() });
+	"held",
+	"sent"
+]).optional() }), object({ files: array(object({
+	id: string$2(),
+	url: string$2().url()
+})) });
+object({ images: array(object({
+	name: string$2(),
+	url: string$2().url().nullable()
+})) });
 strictObject({
 	exit: _enum(REQUEST_EXITS),
 	comment: string$2().trim().min(1).max(PLAN_REJECTION_COMMENT_MAX_CHARS).optional(),
-	force: boolean().optional()
+	force: boolean().optional(),
+	seen: array(string$2().uuid()).max(REVIEW_SEEN_MAX).optional()
 }).refine((answer) => answer.exit === "reject" === (answer.comment !== void 0), {
 	message: "A rejection takes a comment for the planner, and no other answer takes one.",
 	path: ["comment"]
 }).refine((answer) => answer.exit === "replan" || answer.force === void 0, {
 	message: "Only Plan again can plan anyway.",
 	path: ["force"]
+}).refine((answer) => answer.exit === "reviewed" || answer.seen === void 0, {
+	message: "Only Mark reviewed says what was shown.",
+	path: ["seen"]
 });
 strictObject({ type: productDocumentType }), object({
 	version: number$1().int().min(1),
@@ -26830,7 +27284,7 @@ strictObject({ type: productDocumentType }), object({
 		shown: array(string$2()),
 		count: number$1().int().min(0)
 	})
-}), strictObject({ type: productDocumentType }), strictObject({ type: productDocumentType }), object({ documentId: string$2().uuid() }), strictObject({
+}), strictObject({ type: productDocumentType }), strictObject({ type: productDocumentType }), strictObject({
 	githubRepositoryId: uuid.optional(),
 	/** A GitLab project, by the connection whose bot reaches it and GitLab's numeric id (P-PRO-150). */
 	gitlabConnectionId: uuid.optional(),
@@ -26852,13 +27306,19 @@ strictObject({ type: productDocumentType }), object({
 		enforcementLevel: string$2().nullable()
 	}).nullable()
 }), strictObject({
-	license: string$2().trim().min(1).max(200),
+	license: string$2().trim().min(1).max(MAINTENANCE_LICENSE_FILTER_MAX),
 	ignoreReason: _enum(MAINTENANCE_IGNORE_REASONS),
 	ignoreNote,
 	ignoreExpiresAt
 }).refine((args) => expiresInFuture(args.ignoreExpiresAt), EXPIRY_IN_FUTURE), strictObject({
-	license: string$2().trim().min(1).max(200),
+	license: string$2().trim().min(1).max(MAINTENANCE_LICENSE_FILTER_MAX),
 	findingIds: array(uuid).min(1).optional()
+}), strictObject({ license: string$2().trim().min(1).max(MAINTENANCE_LICENSE_FILTER_MAX) }), object({
+	backlogItemIds: array(string$2()),
+	findingCount: number$1()
+}), strictObject({}), object({
+	backlogItemId: string$2(),
+	created: boolean()
 }), strictObject({ host: string$2().trim().toLowerCase().refine(isProductNetworkHost, { message: "A host is one exact DNS name, such as api.example.com: no wildcard, scheme, port or path" }).refine((host) => !isSharedHostingDomain(host), { message: "Anyone can host content on this domain, so it cannot be listed whole; list the one host you need under it" }) }), strictObject({
 	type: _enum(AGENT_JOB_TYPES),
 	documentType: string$2().max(30).optional(),
@@ -26902,15 +27362,16 @@ strictObject({ type: productDocumentType }), object({
 }), strictObject({
 	...policyFixOptions,
 	controlId: string$2().min(1).max(40)
-}), strictObject({ environments: array(string$2()).default(["development"]) }), strictObject({
-	connection: object({
-		name: string$2().min(1).max(150),
-		provider: _enum(CLOUD_PROVIDERS),
-		providerConfig: cloudProviderConfig
-	}).refine((connection) => connection.provider === connection.providerConfig.provider, {
-		message: "connection.provider must match connection.providerConfig.provider",
-		path: ["providerConfig", "provider"]
-	}),
+}), strictObject({
+	controlId: string$2().min(1).max(40),
+	validMonths: union([
+		literal(3),
+		literal(6),
+		literal(12)
+	]),
+	note: string$2().trim().max(1e3).optional()
+}), strictObject({ environments: array(string$2()).default(["development"]) }), object({ id: string$2().uuid() }), strictObject({
+	connection: newCloudConnection,
 	environment: object({
 		name: string$2().min(1).max(100),
 		slug: string$2().min(1).max(63).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug must be lowercase letters, digits, and dashes"),
@@ -26919,13 +27380,159 @@ strictObject({ type: productDocumentType }), object({
 		isProtected: boolean().default(false)
 	}).optional()
 });
+/**
+* The MCP toolsets a key's AI tool sees: at least one, each once, or null for
+* every one (PRO-2838). An empty list would start a server with no tools at all.
+*/
+const mcpToolsets = array(_enum(MCP_TOOLSETS)).min(1).refine((sets) => new Set(sets).size === sets.length, "Name each toolset once").nullable();
+strictObject({
+	key: string$2().regex(new RegExp(`^${API_KEY_PREFIX}[0-9a-f]{64}$`)),
+	name: string$2().min(1).max(255),
+	scopes: array(_enum(API_KEY_SCOPES)).optional(),
+	expiresInDays: number$1().int().min(1).max(365).optional(),
+	mcpToolsets: mcpToolsets.optional()
+}), object({ keyId: uuid });
+strictObject({ mcpToolsets });
+object({
+	url: string$2().url(),
+	expiresAt: string$2()
+});
+object({
+	opens: number$1().int().nonnegative(),
+	closes: number$1().int().nonnegative(),
+	products: array(object({
+		productId: string$2().uuid(),
+		opens: number$1().int().nonnegative(),
+		closes: number$1().int().nonnegative()
+	}))
+});
 object({
 	status: customDocumentStatus.nullable(),
 	/** The retry itself threw; absent when it went through. */
 	error: string$2().optional()
 });
-strictObject({ type: _enum([...FACTORY_DOCUMENT_TYPES, LEGACY_FACTORY_INSTRUCTIONS_TYPE]).transform((type) => type === "team_instructions" ? FACTORY_INSTRUCTIONS_TYPE : type) });
-strictObject({ type: _enum(TENANT_DOCUMENT_TYPES) }), strictObject({
+/** A factory document type, its legacy name read as the current one. */
+const factoryDocumentType = _enum([...FACTORY_DOCUMENT_TYPES, LEGACY_FACTORY_INSTRUCTIONS_TYPE]).transform((type) => type === "team_instructions" ? FACTORY_INSTRUCTIONS_TYPE : type);
+strictObject({ type: factoryDocumentType }), strictObject({ type: factoryDocumentType });
+/**
+* A registry scope: an npm scope ("@acme") or a Go module path prefix
+* ("github.com/acme"), as `POST /registries` takes one (PRO-3670). Which
+* ecosystem takes which is the service's rule.
+*/
+const namedSegments = (value) => value.split("/").every((seg) => seg !== "" && seg !== "." && seg !== "..");
+const registryScope = string$2().regex(/^@?[A-Za-z0-9][A-Za-z0-9._~/-]*$/, "Not a valid scope").max(214).refine(namedSegments, "Not a valid scope");
+/** The package a registry's check fetches, in the union of the ecosystems' grammars. */
+const registryTestPackage = string$2().min(1).max(214).regex(/^@?[A-Za-z0-9_][A-Za-z0-9._~/:-]*$/, "Must be a valid package name").refine(namedSegments, "Must be a valid package name");
+/** KMS direct-encrypt takes 4096 bytes; the raw secret stays well under. */
+const REGISTRY_CREDENTIAL_MAX_BYTES = 3500;
+/** A registry's write-only credential: exactly one of a token, a GCP key or an AWS role, as the route takes it. */
+const registryCredential = strictObject({
+	token: string$2().min(1).max(REGISTRY_CREDENTIAL_MAX_BYTES).optional(),
+	username: string$2().min(1).max(256).regex(/^[^:\s]+$/, "Username must not contain a colon or whitespace").optional(),
+	credentialsJson: string$2().min(2).max(REGISTRY_CREDENTIAL_MAX_BYTES).optional(),
+	awsRoleArn: string$2().max(600).regex(AWS_ROLE_ARN_PATTERN, "Not an IAM role ARN").optional()
+}).refine((c) => [
+	c.token,
+	c.credentialsJson,
+	c.awsRoleArn
+].filter((v) => v != null).length === 1, { message: "Provide exactly one of token, credentialsJson or awsRoleArn" }).refine((c) => c.username == null || c.token != null, { message: "A username goes with a token" }).refine((c) => new TextEncoder().encode(JSON.stringify(c)).length <= 4e3, { message: "Credential is too large to encrypt (must be under 4 KB once JSON-encoded)" });
+/** An instant as an ISO string, which the service reads as a date. */
+const isoInstant = string$2().datetime({ offset: true });
+object({
+	status: _enum([
+		"unvalidated",
+		"valid",
+		"auth_failed",
+		"unreachable"
+	]),
+	lastValidatedAt: string$2(),
+	detail: string$2().nullable()
+});
+strictObject({
+	displayName: string$2().min(1).max(255).optional(),
+	registryUrl: string$2().url().max(512).optional(),
+	scopes: array(registryScope).max(50).optional(),
+	expiresAt: isoInstant.nullable().optional(),
+	credential: registryCredential.optional(),
+	testPackage: registryTestPackage.nullable().optional()
+});
+/** A GitLab bot token, as the route takes one. */
+const gitlabToken = string$2().trim().min(20, "That does not look like a GitLab access token").max(1024).regex(/^[A-Za-z0-9_.-]+$/, "That does not look like a GitLab access token");
+/** A private CA as PEM certificates; the service parses it. */
+const gitlabCaBundle = string$2().min(1).max(65536);
+/** What a connect or a token change learned, beyond the connection's record. */
+const gitlabValidationReport = object({
+	pushableProjectCount: number$1().int().nullable(),
+	warnings: array(string$2())
+});
+strictObject({
+	displayName: string$2().trim().min(1).max(255).optional(),
+	token: gitlabToken.optional(),
+	caBundlePem: gitlabCaBundle.nullable().optional()
+}), gitlabValidationReport.optional(), object({
+	status: _enum(GITLAB_CONNECTION_STATUSES),
+	lastValidatedAt: string$2(),
+	detail: string$2().nullable()
+}), object({ finished: boolean() }), strictObject({ search: string$2().trim().max(100).optional() }), object({
+	projects: array(object({
+		id: number$1().int(),
+		pathWithNamespace: string$2(),
+		nameWithNamespace: string$2(),
+		webUrl: string$2(),
+		defaultBranch: string$2().nullable()
+	})).nullable(),
+	truncated: boolean()
+});
+object({
+	outcome: _enum([
+		"uninstalled",
+		"left_in_use",
+		"uninstall_failed"
+	]),
+	manageUrl: string$2().nullable()
+});
+/** A value GitHub's redirect carries back: a state token, or a one-time code. */
+const githubCallbackSecret = string$2().trim().min(1).max(1024);
+strictObject({
+	displayName: string$2().trim().min(1).max(255),
+	baseUrl: string$2().trim().min(1).max(480),
+	token: gitlabToken,
+	caBundlePem: gitlabCaBundle.nullable().optional()
+}), object({
+	connectionId: uuid,
+	validation: gitlabValidationReport
+}), strictObject({
+	displayName: string$2().min(1).max(255),
+	ecosystem: _enum(REGISTRY_ECOSYSTEMS).optional(),
+	vendor: _enum(REGISTRY_VENDORS),
+	registryUrl: string$2().url().max(512),
+	scopes: array(registryScope).max(50).optional(),
+	expiresAt: isoInstant.nullable().optional(),
+	credential: registryCredential,
+	testPackage: registryTestPackage.optional()
+}), strictObject({ hostId: uuid.optional() }), object({ installUrl: string$2().url() }), strictObject({ state: githubCallbackSecret }), object({
+	clientId: string$2(),
+	authorizeUrl: string$2(),
+	redirectUri: string$2().optional()
+}), strictObject({
+	installationId: number$1().int().positive(),
+	setupAction: _enum(["install", "update"]),
+	state: githubCallbackSecret.optional(),
+	code: githubCallbackSecret.optional()
+}), strictObject({
+	subdomain: string$2().min(1).max(39).optional(),
+	serverUrl: string$2().min(1).max(2048).optional(),
+	caBundlePem: string$2().max(65536).optional(),
+	orgLogin: string$2().min(1).max(39),
+	displayName: string$2().max(255).optional()
+}), object({
+	manifest: record(string$2(), unknown$1()),
+	postUrl: string$2().url(),
+	state: string$2()
+}), strictObject({
+	state: githubCallbackSecret,
+	code: githubCallbackSecret
+}), strictObject({ type: _enum(TENANT_DOCUMENT_TYPES) }), strictObject({ type: _enum(TENANT_DOCUMENT_TYPES).refine((type) => type !== "design_standards", { message: "The design standards draft is not made through sync" }) }), strictObject({
 	name: string$2().min(1).max(50),
 	action: _enum(["accept", "decline"])
 }), object({
@@ -26964,7 +27571,26 @@ strictObject({ type: _enum(TENANT_DOCUMENT_TYPES) }), strictObject({
 }), strictObject({ ids: array(uuid).min(1).max(25) }), object({ referenced: array(string$2()) }), strictObject({
 	approve: array(string$2().min(1).max(100)).max(200).default([]),
 	remove: array(string$2().min(1).max(100)).max(200).default([])
-}).refine((b) => b.approve.length + b.remove.length > 0, { message: "Name a license to approve or remove" }), object({ version: number$1().nullable() });
+}).refine((b) => b.approve.length + b.remove.length > 0, { message: "Name a license to approve or remove" }), object({ version: number$1().nullable() }), strictObject({
+	approve: string$2().trim().min(1).max(100).optional(),
+	remove: string$2().trim().min(1).max(100).optional()
+}).refine((a) => Boolean(a.approve) !== Boolean(a.remove), { message: "Name one license to approve or remove" }), object({
+	enrolled: number$1().int().nonnegative(),
+	total: number$1().int().nonnegative()
+}), object({
+	principalArn: string$2().nullable(),
+	externalId: string$2()
+});
+strictObject({ kind: _enum(["sbom", "notices"]) }), object({
+	url: string$2().url().nullable(),
+	expiresAt: string$2().nullable()
+}), object({
+	branches: array(object({
+		name: string$2(),
+		protected: boolean()
+	})).nullable(),
+	truncated: boolean()
+});
 strictObject({
 	ignoreReason: _enum(MAINTENANCE_IGNORE_REASONS),
 	ignoreNote,
@@ -26976,6 +27602,11 @@ strictObject({ tier: _enum([
 	"staging",
 	"production"
 ]) });
+strictObject({
+	name: string$2().min(1).max(150).optional(),
+	status: _enum(CLOUD_CONNECTION_STATUSES).optional(),
+	providerConfig: record(string$2(), unknown$1()).refine(isTenantWritableProviderConfig, { message: TAIGA_MANAGED_PROVIDER_CONFIG_MESSAGE }).optional()
+});
 object({
 	url: string$2().url(),
 	expiresAt: string$2(),
@@ -27167,6 +27798,7 @@ const TOOLSET_OF = {
 	taiga_fix_finding: "operate",
 	taiga_fix_policy_violation: "operate",
 	taiga_ignore_finding: "operate",
+	taiga_allow_license: "operate",
 	taiga_resolve_action: "operate",
 	taiga_create_factory: "setup",
 	taiga_rename_factory: "setup",
@@ -27191,6 +27823,7 @@ const TOOLSET_OF = {
 	taiga_pause_line: "setup",
 	taiga_create_environment: "setup",
 	taiga_update_environment: "setup",
+	taiga_ship_notices: "setup",
 	taiga_get_deployments: "observe",
 	taiga_get_monitoring: "observe",
 	taiga_get_delivery_metrics: "observe",
@@ -27242,6 +27875,7 @@ const DELIVERY_TOOLS = /* @__PURE__ */ new Set([
 	"taiga_request_initiatives",
 	"taiga_fix_finding",
 	"taiga_fix_policy_violation",
+	"taiga_ship_notices",
 	"taiga_set_auto_build",
 	"taiga_set_auto_merge",
 	"taiga_pause_line",
@@ -27491,7 +28125,6 @@ function setupNextStep(product) {
 	if (product.discoveryStep === void 0) return null;
 	switch (product.discoveryStep) {
 		case "documents": return `The specification is done; the other documents are generated from it (taiga_generate_product_documents starts the ones still missing). Once every required one is published, ${FINISH_DISCOVERY}`;
-		case "checks": return `The documents are published; the checks are stamped in the web, then ${FINISH_DISCOVERY}`;
 		default: return `Discovery is a conversation held in the web: the person describes the product there and the specification comes out of it. The other documents follow, then ${FINISH_DISCOVERY}`;
 	}
 }
@@ -27520,8 +28153,16 @@ const BY_ARGUMENT = {
 	knowledgeId: "taiga_list_knowledge lists the knowledge files.",
 	productId: "taiga_list_products lists the products the key can see; a name is not an ID (taiga_get_product takes a slug)."
 };
+/**
+* A licence a product does not hold, as against a product the key cannot see
+* (PRO-3879). Any other 404 (the routes do not exist where the licenses
+* feature is off) blames neither.
+*/
+const licenseMiss = (hint) => (said) => /\blicen[cs]e\b/i.test(said) ? hint : /\b(product|project) not found/i.test(said) ? BY_ARGUMENT["productId"] : void 0;
 /** Where an argument means something else on one tool, or the tool's 404 needs its own word. */
 const BY_TOOL = {
+	taiga_allow_license: licenseMiss("taiga_list_packages (productId) summarizes the product's licenses as its findings name them; a license with no finding there has nothing to allow or reopen."),
+	taiga_list_licenses: licenseMiss("taiga_list_licenses without license lists the licenses in use, and taiga_list_packages (productId) one product's, spelled as their findings spell them."),
 	taiga_resolve_action: () => "taiga_list_action_required lists the items with their IDs.",
 	taiga_get_sbom: () => "An SBOM exists once a sweep has inventoried that repository, where the licenses feature is enabled; taiga_list_packages (linkId) says whether it has packages, and taiga_list_product_repositories lists the links.",
 	taiga_get_notices: () => "Notices exist once a sweep has inventoried that repository, where the licenses feature is enabled; taiga_list_product_repositories lists the links.",
@@ -27998,6 +28639,8 @@ const PACKAGE_ROW_FIELDS = [
 	"scopeReason",
 	"parentReason",
 	"sourcePath",
+	"baseImage",
+	"imageLayer",
 	"productRepositoryId",
 	"detectedAt"
 ];
@@ -28019,7 +28662,11 @@ const FINDING_ROW_FIELDS = [
 	"tier",
 	"kevListedAt",
 	"malicious",
+	"baseMove",
+	"baseImageMove",
+	"baseImageFix",
 	"removal",
+	"replaceable",
 	"status",
 	"title",
 	"ecosystem",
@@ -28145,14 +28792,22 @@ function withFixability(row) {
 		return {
 			...row,
 			fixable: false,
-			fixNote: reason === "not_shipped" ? "No longer applies: the package is only a build for platforms the repository does not deploy to. Nothing to do." : reason === "license_approved" ? "No longer applies: its license is on the organization's approved list. Nothing to do." : reason === "license_undecided" ? "No longer applies: its license can no longer be judged against the list (some of what it can stand for is approved). Nothing to do." : reason === "superseded" ? "Replaced by the repository's finding of its license, which lists every package under it. Nothing to do here." : "Resolved: the sweep no longer reports it. Nothing to do."
+			fixNote: reason === "not_shipped" ? "No longer applies: the package is only a build for platforms the repository does not deploy to. Nothing to do." : reason === "license_approved" ? "No longer applies: its license is on the organization's approved list. Nothing to do." : reason === "license_undecided" ? "No longer applies: its license can no longer be judged against the list (some of what it can stand for is approved). Nothing to do." : reason === "superseded" ? "Replaced by the repository's finding of its license, which lists every package under it. Nothing to do here." : reason === "license_not_judged" ? "No longer applies: an OS package's license is judged only when it restricts use. Its packages keep it. Nothing to do." : "Resolved: the sweep no longer reports it. Nothing to do."
 		};
 	}
-	if (row["kind"] === "license_violation") return {
+	if (row["kind"] === "license_violation" && row["replaceable"] === true) return {
 		...row,
-		fixable: false,
-		fixNote: "A license violation has no fix version: approve the license (taiga_change_license), ignore the finding, or replace the packages under it; taiga_fix_finding refuses it."
+		fixable: true,
+		fixNote: "taiga_fix_finding raises an initiative that replaces the packages under this license with ones whose license, and their own dependencies' licenses, are on the approved list. It never approves the license: that is taiga_change_license, or ignoring the finding."
 	};
+	if (row["kind"] === "license_violation") {
+		const status = String(row["status"]);
+		return {
+			...row,
+			fixable: false,
+			fixNote: status === "remediating" ? "Being fixed: an initiative replaces the packages under this license, and its plan may be waiting for a person's review. taiga_list_initiatives with query \"Replace the\" finds it; follow it there." : status === "open" ? "This Taiga does not replace the packages under a license yet, so taiga_fix_finding refuses it: approve the license (taiga_change_license) or ignore the finding." : `taiga_fix_finding takes only an open license finding, and this one is ${status}.`
+		};
+	}
 	const dependency = row["kind"] === "vulnerable_dependency" || row["kind"] === "outdated_dependency";
 	const signals = {
 		malicious: typeof row["malicious"] === "boolean" ? row["malicious"] : null,
@@ -28176,6 +28831,38 @@ function withFixability(row) {
 		fixable: true,
 		fixNote: "A malicious package: taiga_fix_finding removes it (or replaces it), with every advisory on that version."
 	} : row;
+	const held = row["autoFixHeld"];
+	const inBase = row["baseImageFix"] != null || typeof row["baseMove"] === "boolean";
+	if (row["status"] === "open" && !inBase && held && isPinBlocked({ autoFixHeld: held })) {
+		const what = held.blockingPackage ?? "another dependency";
+		return {
+			...row,
+			fixable: false,
+			fixNote: `Waiting on ${what}${held.blockingConstraint ? `, which requires ${held.blockingConstraint}` : ""}. taiga_fix_finding refuses it until that moves.`
+		};
+	}
+	const base = row["baseImageFix"];
+	if (base && base.way !== "move" && isAgentRemediable({ remediableBy: remediableByOf(row) })) {
+		if (base.way === "upgrade") return row["status"] === "open" ? {
+			...row,
+			fixable: true,
+			fixNote: "taiga_fix_finding adds a temporary line to the Dockerfile that upgrades this package over its base, until the base publishes a build with the fix."
+		} : row;
+		return {
+			...row,
+			fixable: false,
+			fixNote: baseImageWaitNote(base)
+		};
+	}
+	if (typeof row["baseMove"] === "boolean" && isAgentRemediable({ remediableBy: remediableByOf(row) })) return row["baseMove"] === true && row["status"] === "open" ? {
+		...row,
+		fixable: true,
+		fixNote: "taiga_fix_finding moves the base images it is in to the builds their tags name now, the FROM line alone, with every other advisory that move removes."
+	} : {
+		...row,
+		fixable: false,
+		fixNote: "Inside a base image no newer build of which removes it yet: it is fixed by a base move, not a package bump, and is held until one does."
+	};
 	if (dependency && !row["recommendedVersion"] && row["remediableBy"] === "coding_agent") return {
 		...row,
 		fixable: false,
@@ -28237,6 +28924,14 @@ function withResolutionLabel(row) {
 		previouslyResolvedReason: resolvedReason
 	};
 }
+/** Why a base image's finding has no Fix, in the page's words (`maintaining_base_wait_*`). */
+function baseImageWaitNote(fix) {
+	if (fix.way === "wait_for_distro") return `${fix.distro} has no fix for this yet.`;
+	if (fix.way === "end_of_life") return `${fix.distro} has reached its end of life, so upgrading this one package is no fix. It clears when the base moves to a supported release.`;
+	const image = fix.images.join(", ") || "The base image";
+	return `${fix.distro} has fixed this, but ${image} has not published a build with the fix yet. It clears when it does.`;
+}
+const remediableByOf = (row) => typeof row["remediableBy"] === "string" ? row["remediableBy"] : null;
 /** A finding as a tool answers it: the row fields, the scope, and whether Fix would take it. */
 function findingRows(findings, extra = []) {
 	return pickFields(findings, [
@@ -28253,7 +28948,10 @@ const ADVISORY_KEPT = [
 	"summary",
 	"details",
 	"severity",
-	"published"
+	"severitySource",
+	"cvssScore",
+	"published",
+	"baseImage"
 ];
 const ADVISORY_TEXT_LIMIT = 1500;
 /** The packages of a licence finding shown without full: true (PRO-3394); the rest are counted. */
@@ -28294,6 +28992,36 @@ const SWEEP_FIELDS = [
 	"createdAt",
 	"completedAt"
 ];
+/**
+* The images a sweep's shipped images build on that it could not read, and
+* why (PRO-4073): a base nobody read is no clean base. Only where the API
+* returns the list (null with the containerImages flag off, or from a sweep
+* that listed none).
+*/
+const BASE_IMAGES_SHOWN = 10;
+function notReadBases(sweep) {
+	const bases = sweep.baseImages ?? [];
+	const notRead = bases.filter((b) => b.state === "not_read" || b.packages?.state === "not_read");
+	const read = bases.flatMap((b) => b.packages?.state === "read" ? [{
+		image: b.image,
+		path: b.path,
+		os: b.os ?? null,
+		vulnerabilities: b.packages.vulnerabilities,
+		removedByMoving: b.packages.candidate?.removes ?? 0,
+		noDistroFix: b.packages.noDistroFix ?? null,
+		movesTo: b.packages.candidate?.image ?? null
+	}] : []);
+	return {
+		...read.length > 0 ? {
+			baseImages: read.slice(0, BASE_IMAGES_SHOWN),
+			...read.length > BASE_IMAGES_SHOWN ? { baseImagesCount: read.length } : {}
+		} : {},
+		...notRead.length > 0 ? {
+			baseImagesNotRead: notRead.slice(0, BASE_IMAGES_SHOWN),
+			...notRead.length > BASE_IMAGES_SHOWN ? { baseImagesNotReadCount: notRead.length } : {}
+		} : {}
+	};
+}
 /** A policy violation in a list: what it is, how bad, and what is being done about it. */
 const VIOLATION_FIELDS = [
 	"id",
@@ -28350,11 +29078,51 @@ function standingSummary(standing) {
 		resolvedViolations: resolved
 	};
 }
+/**
+* How the backlog covers the controls that need a feature (PRO-3860), one row
+* each: the live initiatives that build it, or why it is deferred, and whether
+* nothing covers it. Empty before a backlog answered for any. It says what is
+* planned, never that a control is met.
+*/
+function controlCoverageList(controls) {
+	return (Array.isArray(controls) ? controls : []).flatMap((control) => {
+		const coverage = control["coverage"];
+		if (!coverage || typeof coverage !== "object") return [];
+		const initiatives = Array.isArray(coverage["initiatives"]) ? coverage["initiatives"] : [];
+		return [{
+			controlId: control["controlId"],
+			state: control["state"],
+			planned: plannedFor(coverage),
+			uncovered: coverage["uncovered"] === true,
+			...initiatives.length > 0 ? { initiatives: initiatives.map((item) => ({
+				id: item["id"],
+				title: item["title"]
+			})) } : {},
+			...coverage["deferredReason"] ? { deferredReason: coverage["deferredReason"] } : {}
+		}];
+	});
+}
+/**
+* Whether the backlog plans a control: yes when a live initiative builds it, later when it deferred it with a
+* reason, no otherwise. A deferred control reads "planned later" rather than only "not assessed" (PRO-3860).
+*/
+function plannedFor(coverage) {
+	if (Array.isArray(coverage["initiatives"]) && coverage["initiatives"].length > 0) return "yes";
+	return coverage["deferredReason"] ? "later" : "no";
+}
+/** The coverage, when the backlog answered for any control, for the default and full answers. */
+function controlCoveragePart(controls) {
+	const coverage = controlCoverageList(controls);
+	return coverage.length > 0 ? { controlCoverage: coverage } : {};
+}
 const findingId = idInput("finding", "taiga_list_findings gives it");
 /** Open findings by severity and kind, and the latest sweeps, as the first page of findings carries them. */
 async function sweepOverview(client, productId) {
 	const [summary, sweeps] = await Promise.all([client.getMaintenanceSummary(productId), client.listMaintenanceSweeps(productId, { limit: 3 })]);
-	const latest = pickFields(sweeps.data, SWEEP_FIELDS);
+	const latest = sweeps.data.map((sweep) => ({
+		...pickFields([sweep], SWEEP_FIELDS)[0],
+		...notReadBases(sweep)
+	}));
 	const { lastRun: _lastRun, lastRuns: _lastRuns, topFindings: _top, violatedControls: _controls, ...counts } = summary.data;
 	return {
 		...counts,
@@ -28362,6 +29130,20 @@ async function sweepOverview(client, productId) {
 		...latest.length === 0 ? { note: "This product has never been swept: no findings is not an all-clear." } : {}
 	};
 }
+/** The organization's licence read takes an id this long at most, as `organizationLicenseQuery` does. */
+const ORGANIZATION_LICENSE_MAX = 200;
+/**
+* Why a license is allowed in a product, in a license's words, as the web's
+* Allow dialog offers them (PRO-3727); each is stored as the ignore reason
+* beside it.
+*/
+const LICENSE_ALLOW_REASON_TO_IGNORE = {
+	accepted: "accepted_risk",
+	not_handed_out: "not_reachable",
+	no_alternative: "wont_fix",
+	read_wrong: "false_positive"
+};
+const LICENSE_ALLOW_REASONS = Object.keys(LICENSE_ALLOW_REASON_TO_IGNORE);
 function registerMaintenanceTools(server, client) {
 	if (client.hasCapability("tenant:settings")) server.registerTool("taiga_change_license", {
 		title: "Approve or remove a license",
@@ -28449,10 +29231,18 @@ function registerMaintenanceTools(server, client) {
 	}));
 	server.registerTool("taiga_list_licenses", {
 		title: "List the organization's licenses",
-		description: "List the organization's approved license list and every license in use across its products, approved or not, with packages, products and repositories. With license, where that one is used: products, repositories and what brings its packages in. NOT_FOUND where the licenses feature is off.",
-		inputSchema: object({ license: string$2().trim().min(1).max(200).optional().describe("An SPDX license id: where it is used, instead of the list") }),
+		description: "List the organization's approved license list and every license in use across its products, approved or not, with packages, products and repositories. With license, where that one is used: products, repositories, what brings its packages in, and its approved-list history. With license and productId, that license in one product: its standing against the list, what it asks, when to allow it there, how many packages ship, and what brings them in. Decide it there with taiga_allow_license. NOT_FOUND where the licenses feature is off.",
+		inputSchema: object({
+			license: string$2().trim().min(1).max(MAINTENANCE_LICENSE_FILTER_MAX).optional().describe("An SPDX license id or expression: where it is used, instead of the list"),
+			productId: productId.optional().describe("With license: that license in this product only (taiga_list_products gives it)")
+		}),
 		annotations: READ_ONLY
-	}, (params) => runTool(async () => toolResult(params.license ? (await client.getOrganizationLicense(params.license)).data : (await client.getOrganizationLicenses()).data)));
+	}, (params) => runTool(async () => {
+		if (params.productId !== void 0 && params.license === void 0) return toolError("VALIDATION_ERROR", "Name the license to read in this product (license).");
+		if (params.license === void 0) return toolResult((await client.getOrganizationLicenses()).data);
+		if (params.productId === void 0 && params.license.length > ORGANIZATION_LICENSE_MAX) return toolError("VALIDATION_ERROR", `A license id is at most ${ORGANIZATION_LICENSE_MAX} characters; name a product (productId) to read a longer expression.`);
+		return toolResult(params.productId !== void 0 ? (await client.getProductLicense(params.productId, params.license)).data : (await client.getOrganizationLicense(params.license)).data);
+	}));
 	server.registerTool("taiga_get_sbom", {
 		title: "Download a repository SBOM",
 		description: "Download one repository's software bill of materials (CycloneDX 1.6). Large; taiga_list_packages summarizes. NOT_FOUND where the licenses feature is off, or before a sweep has read the repository.",
@@ -28519,7 +29309,8 @@ function registerMaintenanceTools(server, client) {
 			const own = violations.filter((violation) => String(violation["controlId"]).toUpperCase() === wanted);
 			return toolResult({
 				...control,
-				...control.state === "no_evidence" ? { meaning: "Not assessed: no finding or violation is recorded against it, and the documents were not found to show it met. That is no evidence either way, not a pass." } : {},
+				...control.state === "no_evidence" ? { meaning: (control.coverage && plannedFor(control.coverage) === "later" ? `Planned later: the backlog deferred it (${String(control.coverage.deferredReason).replace(/\.$/, "")}). ` : "") + "Not assessed: no finding or violation is recorded against it, and the documents were not found to show it met. That is no evidence either way, not a pass." } : {},
+				...control.coverage ? { coverageNote: "coverage is how the backlog plans for it: the live initiatives that build it, or why it is deferred. It says what is planned, not that the control is met." } : {},
 				...control.assessment == null && (control.state === "breached" || control.state === "diverged") ? { assessmentNote: "No met or not-applicable verdict is shown: an open finding or violation against the control outranks one." } : {},
 				...Number(control.findingCount ?? 0) > 0 ? { findingsNote: `${String(control.findingCount)} open scanner finding${control.findingCount === 1 ? "" : "s"} breach it; taiga_list_findings (productId) lists them with the controls each breaches. violations below are the documents' only.` } : {},
 				violations: pickFields(own, VIOLATION_FIELDS),
@@ -28542,6 +29333,7 @@ function registerMaintenanceTools(server, client) {
 				...wording,
 				...standing,
 				controls: listed,
+				...controlCoveragePart(controls),
 				divergences: cutLongText(violations),
 				resolvedDivergences: cutLongText(resolvedAll.slice(0, FULL_RESOLVED)),
 				...resolvedAll.length > FULL_RESOLVED ? { resolvedNote: `The first ${FULL_RESOLVED} of ${resolvedAll.length} resolved violations.` } : {}
@@ -28565,7 +29357,8 @@ function registerMaintenanceTools(server, client) {
 				"findingsByTier",
 				"plannedCount"
 			]),
-			violations: pickFields(violations, VIOLATION_FIELDS)
+			violations: pickFields(violations, VIOLATION_FIELDS),
+			...controlCoveragePart(controls)
 		});
 	}));
 	if (!client.hasCapability("products:write")) return;
@@ -28591,9 +29384,31 @@ function registerMaintenanceTools(server, client) {
 		const finding = (await client.updateFinding(params.findingId, body)).data;
 		return toolResult(findingRows([finding], ["ignoreNote"])[0]);
 	}));
+	server.registerTool("taiga_allow_license", {
+		title: "Allow or reopen a license in a product",
+		description: "Allow a license in one product without approving it for the organization: every license finding of it there that is open, or whose ignore lapsed, is ignored with one reason, as the web's Allow in this product does; one already ignored keeps its reason and expiry, so reopen first to change them. allowed: false reopens them. Another product using the license still raises its finding; to approve it everywhere, use taiga_change_license. Allowing a license is the person's decision. NOT_FOUND when the product has no license finding for it.",
+		inputSchema: object({
+			productId,
+			license: string$2().trim().min(1).max(MAINTENANCE_LICENSE_FILTER_MAX).describe("The license as the product's license findings or taiga_list_packages name it, such as MPL-2.0"),
+			allowed: boolean().describe("true allows the license in this product, false reopens its findings"),
+			reason: _enum(LICENSE_ALLOW_REASONS).optional().describe("Why it is allowed; required when allowing. accepted: reviewed and allowed here, usually for a limited time; not_handed_out: the product runs only internally or on your own servers, its code is never given to anyone; no_alternative: no package under an approved license does the job yet; read_wrong: the packages are not actually under this license"),
+			note: string$2().trim().max(280).optional().describe("A short justification, kept for audit"),
+			expiresAt: string$2().datetime({ offset: true }).meta({ pattern: void 0 }).optional().describe("When the allowance lapses and the findings come back if still there (ISO 8601, in the future)")
+		}),
+		annotations: OPERATE_SETTING
+	}, (params) => runTool(async () => {
+		if (!params.allowed) return toolResult((await client.reopenProductLicense(params.productId, params.license)).data);
+		if (params.reason === void 0) return toolError("VALIDATION_ERROR", "Say why the license is allowed (reason).");
+		return toolResult((await client.allowProductLicense(params.productId, {
+			license: params.license,
+			ignoreReason: LICENSE_ALLOW_REASON_TO_IGNORE[params.reason],
+			...params.note !== void 0 ? { ignoreNote: params.note } : {},
+			...params.expiresAt !== void 0 ? { ignoreExpiresAt: params.expiresAt } : {}
+		})).data);
+	}));
 	server.registerTool("taiga_fix_finding", {
 		title: "Fix a finding",
-		description: "Raise an initiative that fixes a finding; it ends in a pull request, which merges on its own only where the product's auto-merge allows it. wholeGroup: true fixes, in that repository, every open advisory on that package version in one bump, or every place the rule flagged. A malicious package is removed, with every advisory on that version, whatever wholeGroup says. A language runtime moves every file declaring it together, in a container image only to a tag the image has published. Refused when there is no version to move to (fixable: false; for a runtime, also while its image has not published the fix), the code is in a submodule, or a secret is only in history (rotate it outside Taiga).",
+		description: "Raise an initiative that fixes a finding; it ends in a pull request, which merges on its own only where the product's auto-merge allows it. wholeGroup: true fixes, in that repository, every open advisory on that package version in one bump, or every place the rule flagged. A malicious package is removed, with every advisory on that version, whatever wholeGroup says. A license finding the row marks fixable has its packages replaced by ones on the approved list. A language runtime moves every file declaring it together, in a container image only to a tag the image has published. Refused when there is no version to move to (fixable: false; for a runtime, also while its image has not published the fix), the code is in a submodule, or a secret is only in history (rotate it outside Taiga).",
 		inputSchema: object({
 			productId,
 			findingId,
@@ -28632,6 +29447,13 @@ function registerMaintenanceTools(server, client) {
 		const body = { refuseIfFixedSinceAssessment: params.fixAgain !== true };
 		return toolResult((params.controlId ? await client.remediatePolicyControl(params.productId, params.controlId, body) : await client.remediatePolicyViolation(params.productId, params.violationId, body)).data);
 	}));
+	if (!client.hasCapability("backlog:write")) return;
+	server.registerTool("taiga_ship_notices", {
+		title: "Ship open-source notices",
+		description: "Raise the initiative that builds open-source notices into a product's Vite web app: every production build writes the license texts and NOTICE files of the packages in its browser bundle, and the app shows them at /legal/open-source. Taiga writes the brief from the inventory; the plan waits for review before it builds. One that is already open is handed back (created: false) rather than raised again. Refused where no repository of the product declares Vite.",
+		inputSchema: object({ productId }),
+		annotations: OPERATE
+	}, (params) => runTool(async () => toolResult((await client.shipNotices(params.productId)).data)));
 }
 //#endregion
 //#region src/tools/sections.ts
@@ -28957,20 +29779,17 @@ async function setupReadiness(client, product, links) {
 	const settings = product["settings"] ?? {};
 	const importState = imported ? IMPORT_STATE[String(settings.importStatus)] ?? "not started" : void 0;
 	const missing = blockers ? blockers.missingDocuments : null;
-	const openChecks = blockers ? blockers.openChecks.map((check) => check.criterion) : null;
 	return {
-		ready: blockers ? missing.length === 0 && openChecks.length === 0 : null,
+		ready: blockers ? missing.length === 0 : null,
 		repository,
 		...imported ? { import: typeof settings.importStatus === "string" ? settings.importStatus : "pending" } : {},
 		...imported ? {} : { discoveryStep: full["discoveryStep"] ?? null },
 		missingDocuments: missing,
-		openChecks,
 		nextStep: nextStepFor({
 			imported,
 			importState,
 			linked: repository?.linked ?? null,
 			missing,
-			openChecks,
 			product: full
 		})
 	};
@@ -28992,7 +29811,6 @@ function nextStepFor(state) {
 	if (!state.missing) return setupNextStep(state.product);
 	if (state.missing.includes("specification")) return "The specification comes from the Discovery conversation, held in the web: the person describes the product there. The other documents follow from it." + (state.linked === false ? " Linking a repository (taiga_link_repository) can wait until before the first build." : "");
 	if (state.missing.length > 0) return `Still to publish: ${named(state.missing)}. taiga_generate_product_documents generates the missing ones (paid agent work: ask first); a draft is published with taiga_publish_product_document.`;
-	if (state.openChecks && state.openChecks.length > 0) return `The documents are published; the checks are stamped in the web, then ${finish}`;
 	return `Every required document is published: ${finish}`;
 }
 //#endregion
@@ -30076,7 +30894,8 @@ const READY_BLOCKER_SAID = {
 	bar_lowering: "a fix lowered a check instead of fixing the code",
 	bar_lowering_unchecked: "Taiga could not check whether a fix lowered a check",
 	criticals_unresolved: "Taiga's own review left a critical issue unresolved",
-	clean_checkout_failed: "the branch does not install or pass its tests from a clean checkout"
+	clean_checkout_failed: "the branch does not install or pass its tests from a clean checkout",
+	license_not_approved: "a package it adds has a licence that is not on your approved list"
 };
 /** The first sentence of a run's error, short enough for a row. */
 function errorSaid(error) {
@@ -30100,10 +30919,11 @@ function runOutcome(run) {
 	const why = errorSaid(run["error"]) ?? (typeof run["failedReason"] === "string" ? run["failedReason"] : null);
 	const handback = handbackSaid(run["reviewEscalation"]);
 	const draft = run["prDraft"] === true ? `, still a draft` : "";
+	const blocked = reasonOnOneLine(run["factoryBlockedBecause"]);
 	return {
 		disposition,
 		outcome: {
-			in_flight: status === "pending" ? "Queued: waiting to start." : status === "replanning" ? steerPaused(run["failedReason"], progress) : `Running: ${RUNNING[status] ?? status}${progress}.`,
+			in_flight: blocked ? `Blocked: the factory has stopped working on this run${progress}. ${blocked}` : status === "pending" ? "Queued: waiting to start." : status === "replanning" ? steerPaused(run["failedReason"], progress) : `Running: ${RUNNING[status] ?? status}${progress}.`,
 			gated: handback ? `Handed back to a person: ${handback}. ${pr}${draft ? `${draft},` : ""} waits for them to ${handbackNextStep(run["reviewEscalation"], run["provider"])}.` : `Waiting for a person to review and merge ${pr}${draft}.`,
 			succeeded: `Merged: ${pr} is in ${typeof run["baseBranch"] === "string" ? run["baseBranch"] : "the base branch"}.`,
 			unmerged: typeof run["prNumber"] === "number" || run["prUrl"] ? `Settled without merging: ${pr} was left unmerged.` : "Settled without a merged pull request.",
@@ -30127,12 +30947,12 @@ function steerPaused(reason, progress) {
 */
 function replanHandedBack(reason, error, progress) {
 	if (reason !== "replan_refused" && reason !== "replan_failed") return null;
-	const why = plannerReasonSaid(error);
+	const why = reasonOnOneLine(error);
 	if (reason === "replan_refused") return `Stopped${progress}, handed back: the planner would not plan the request for changes${why ? `: ${why}` : "."} Resume continues the original plan.`;
 	return `Stopped${progress}, handed back: ${why ?? "the plan could not be revised."} Resume continues the original plan.`;
 }
 /** A hand-back's reason on one line, ending as a sentence, capped for a row. */
-function plannerReasonSaid(error) {
+function reasonOnOneLine(error) {
 	if (typeof error !== "string") return null;
 	const text = error.replace(/\s+/g, " ").trim();
 	if (!text) return null;
@@ -30218,7 +31038,7 @@ const FAILED_REASON_MEANS = {
 * text out: its first sentence is in the outcome, and taiga_get_run has it all.
 */
 function readableRun(run, opts = {}) {
-	const { prDraft, error, reviewEscalation, runtime: _runtime, origin, ...rest } = run;
+	const { prDraft, error, reviewEscalation, runtime: _runtime, origin, factoryBlockedBecause: _inTheOutcome, ...rest } = run;
 	const said = runOutcome(run);
 	const means = FAILED_REASON_MEANS[String(run["failedReason"])];
 	const hardening = run["hardeningResult"];
@@ -30583,6 +31403,7 @@ function registerBuildTools(server, client) {
 }
 /** What happened to a request that steers a run (PRO-3161), in one sentence. */
 function steerSituation(steer) {
+	if (steer === "sent") return "The run takes it as an instruction while it keeps working.";
 	if (steer === "replanning") return "The run has paused and its plan is being revised for the request.";
 	if (steer === "after_step") return "The run stops when the step it is building ends, then its plan is revised.";
 	if (steer === "after_round") return "The run is answering review comments or fixing CI; the request is planned when that round ends, and no further automatic round starts while it is open.";
@@ -30834,6 +31655,10 @@ function standing(item) {
 	const life = item["lifecycle"];
 	const run = life?.latestBuild;
 	const situation = situationOf(item);
+	const open = (life?.openPullRequests ?? []).flatMap((pull) => typeof pull.repositoryFullName === "string" && typeof pull.prNumber === "number" ? [{
+		repository: pull.repositoryFullName,
+		prNumber: pull.prNumber
+	}] : []);
 	return {
 		column: typeof item["state"] === "string" ? item["state"] : null,
 		turn: typeof life?.turn === "string" ? life.turn : null,
@@ -30841,7 +31666,8 @@ function standing(item) {
 		latestRun: run && typeof run.id === "string" ? {
 			id: run.id,
 			...typeof run.prNumber === "number" ? { prNumber: run.prNumber } : {}
-		} : null
+		} : null,
+		...open.length > 1 ? { pullRequests: open } : {}
 	};
 }
 /** The move each call to action is, in the tools' words. */
@@ -31024,7 +31850,8 @@ const PLAN_SUMMARY_FIELDS = [
 	"backlogItemId",
 	"version",
 	"status",
-	"createdAt"
+	"createdAt",
+	"controls"
 ];
 const PLAN_STEP_SUMMARY_FIELDS = [
 	"id",
@@ -31171,10 +31998,12 @@ function registerBacklogReads(server, client) {
 			...revised
 		});
 		const steps = Array.isArray(plan.steps) ? plan.steps : [];
+		const several = (plan.repositories?.length ?? 0) > 1;
 		return toolResult({
 			...pickFields([plan], PLAN_SUMMARY_FIELDS)[0],
+			...several ? { repositories: plan.repositories } : {},
 			...revised,
-			steps: pickFields(steps, PLAN_STEP_SUMMARY_FIELDS)
+			steps: several ? pickFields(steps, [...PLAN_STEP_SUMMARY_FIELDS, "repositoryName"]) : pickFields(steps, PLAN_STEP_SUMMARY_FIELDS)
 		});
 	}));
 }
@@ -32130,7 +32959,7 @@ async function licenseReviews(client, productId, now) {
 					packages: data["packages"],
 					...Number.isNaN(created) ? {} : { waitingDays: Math.floor((now - created) / DAY_MS) },
 					readWith: "taiga_list_licenses (license)",
-					decideWith: "taiga_change_license (license, action: 'approve'); dismissing it is only in the web"
+					decideWith: "taiga_change_license (license, action: 'approve') for every product" + (client.hasCapability("products:write") ? ", or taiga_allow_license (productId, license) for this one" : "") + "; dismissing it is only in the web"
 				};
 			}).filter((r) => productId === void 0 || r.productId === productId),
 			truncated: result.truncated === true
@@ -48897,7 +49726,7 @@ function registerSetupTools(server, client) {
 	}, (params) => runTool(async () => toolResult((await client.refreshRealityDocuments(params.productId, params.docTypes)).data)));
 	server.registerTool("taiga_finish_discovery", {
 		title: "Finish Discovery",
-		description: "Finish a product's setup: lock its documents and start planning its first initiatives. Refused while documents are missing (the refusal lists them) or a check is not stamped in the web.",
+		description: "Finish a product's setup: lock its documents and start planning its first initiatives. Refused while documents are missing (the refusal lists them).",
 		inputSchema: object({ productId }),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
@@ -49162,6 +49991,7 @@ const PAID_WORK = /* @__PURE__ */ new Set([
 	"taiga_request_changes",
 	"taiga_request_initiatives",
 	"taiga_resume_initiative",
+	"taiga_ship_notices",
 	"taiga_retry_knowledge",
 	"taiga_review_plan",
 	"taiga_set_auto_build",