@taiga-ai/mcp-server 0.36.0-rc.778 → 0.36.0-rc.892

package/dist/index.js

@@ -505,6 +505,7 @@ function hide(inst, key, value) {
 	return own$5(inst, key, value, false);
 }
 /** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
+/* @__NO_SIDE_EFFECTS__ */
 function derived(computes, table) {
 	for (const key in computes) {
 		const compute = computes[key];
@@ -658,6 +659,7 @@ function newError(Definition) {
 	}
 	return new Definition();
 }
+/* @__NO_SIDE_EFFECTS__ */
 function $constructor(name, initializer, proto, params) {
 	const zodProto = {};
 	function Internals(def) {
@@ -788,8 +790,7 @@ const initializer$1 = (inst, def) => {
 		});
 	}
 };
-const $ZodError = $constructor("$ZodError", initializer$1);
-$constructor("$ZodError", initializer$1, void 0, { Parent: Error });
+const $ZodError = /* @__PURE__ */ $constructor("$ZodError", initializer$1);
 /** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
 * ("toString", "constructor") would otherwise read through to the prototype, and assigning
 * "__proto__" would hit the setter instead of creating a key. */
@@ -1078,7 +1079,7 @@ const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9
 /** Returns a regex for validating an RFC 9562/4122 UUID.
 *
 * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
-const uuid = (version) => {
+const uuid$1 = (version) => {
 	if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
 	return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 };
@@ -1618,8 +1619,8 @@ const $ZodUUID = /*@__PURE__*/ $constructor("$ZodUUID", (inst, def) => {
 			v8: 8
 		}[def.version];
 		if (v === void 0) throw new Error(`Invalid UUID version: "${def.version}"`);
-		def.pattern ?? (def.pattern = uuid(v));
-	} else def.pattern ?? (def.pattern = uuid());
+		def.pattern ?? (def.pattern = uuid$1(v));
+	} else def.pattern ?? (def.pattern = uuid$1());
 	$ZodStringFormat.init(inst, def);
 });
 const $ZodEmail = /*@__PURE__*/ $constructor("$ZodEmail", (inst, def) => {
@@ -5675,6 +5676,14 @@ function object(shape, params) {
 	};
 	return new ZodObject(def);
 }
+function strictObject(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape,
+		catchall: never(),
+		...normalizeParams(params)
+	});
+}
 function looseObject(shape, params) {
 	return new ZodObject({
 		type: "object",
@@ -7941,7 +7950,23 @@ var SdkError = class extends Error {
 		stampErrorBrands(this, new.target);
 	}
 };
-(class extends SdkError {
+/**
+* An {@linkcode SdkError} subclass for HTTP transport failures.
+*
+* Thrown by the streamable HTTP transport when the server responds with a
+* non-OK status code. Narrows {@linkcode SdkError.data | data} to
+* {@linkcode SdkHttpErrorData} so consumers can inspect the HTTP status
+* without unsafe casting.
+*
+* @example
+* ```ts source="./sdkErrors.examples.ts#SdkHttpError_basicUsage"
+* if (error instanceof SdkHttpError) {
+*     console.log(error.status); // number
+*     console.log(error.statusText); // string | undefined
+* }
+* ```
+*/
+var SdkHttpError = class extends SdkError {
 	static {
 		Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkHttpError" });
 	}
@@ -7958,7 +7983,7 @@ var SdkError = class extends Error {
 	get statusText() {
 		return this.data.statusText;
 	}
-});
+};
 function isPlainObject$7(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -23874,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");
@@ -23901,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`, {});
 	}
@@ -24040,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`);
 	}
@@ -24089,6 +24130,25 @@ var TaigaClient = class {
 	}
 };
 //#endregion
+//#region ../../packages/types/dist/clouds.js
+/**
+* Cloud provider platforms that Taiga can connect to.
+*/
+const CLOUD_PROVIDERS = [
+	"aws",
+	"gcp",
+	"azure",
+	"upcloud",
+	"kubernetes",
+	"digitalocean",
+	"vercel",
+	"railway",
+	"render",
+	"fly",
+	"on_prem",
+	"other"
+];
+//#endregion
 //#region ../../packages/types/dist/lenient-schema.js
 /**
 * Building blocks for reading JSON that arrives untyped -- a stored jsonb
@@ -24150,6 +24210,14 @@ const optionalUuid = string$2().uuid().optional();
 */
 const optionalLineAnchor = number$1().int().min(0).optional().transform((v) => v ? v : void 0);
 //#endregion
+//#region ../../packages/types/dist/entitlements.js
+/**
+* Which agent implementation serves a planning job or build run (PRO-1331).
+* Recorded on `agent_jobs.runtime` / `build_runs.runtime` at dispatch so
+* outcomes can be compared per runtime and the UI can badge runs.
+*/
+const AGENT_RUNTIMES = ["legacy", "engineer"];
+//#endregion
 //#region ../../packages/types/dist/tenants.js
 const TENANT_DOCUMENT_TYPES = [
 	"policy_security",
@@ -24350,21 +24418,58 @@ 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"];
+/** The single canonical factory-document type (the free-form Factory Instructions doc). */
+const FACTORY_INSTRUCTIONS_TYPE = "factory_instructions";
+/**
+* The pre-PRO-1671 value of that type. Old clients still name it in URLs
+* (`/factories/:id/documents/team_instructions`), so the API accepts it as
+* an alias for a deprecation window.
+*/
+const LEGACY_FACTORY_INSTRUCTIONS_TYPE = "team_instructions";
 //#endregion
 //#region ../../packages/types/dist/forge.js
 /** Source-control hosts. `bitbucket` is a stored link provider without an adapter yet. */
@@ -24416,6 +24521,15 @@ const FORGE_SUPPORT = {
 	],
 	bitbucket: []
 };
+/**
+* Whether a repository link under this forge may name a GitHub App
+* installation's repository: only GitHub's. Stored under another forge, the
+* link would be dispatched with GitHub credentials while the rest of its
+* lifecycle reads it as that forge.
+*/
+function linksGitHubAppRepositories(provider) {
+	return provider === "github";
+}
 const FORGE_TERMS = {
 	github: {
 		name: "GitHub",
@@ -24471,6 +24585,11 @@ const PRODUCT_DOCUMENT_TYPES = [
 	"product_instructions"
 ];
 /**
+* The pre-PRO-1671 value of `product_instructions`. Old clients still name it
+* in URLs, so the API accepts it as an alias for a deprecation window.
+*/
+const LEGACY_PRODUCT_INSTRUCTIONS_TYPE = "project_instructions";
+/**
 * The document types the codebase-intelligence agent can derive from a repo --
 * the valid values for a single-document reality refresh (PRO-1141).
 *
@@ -24566,6 +24685,8 @@ const PRODUCT_DOCUMENT_DISPLAY_NAMES = {
 	service_blueprint: "Service Blueprint"
 };
 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;
 //#endregion
 //#region ../../packages/types/dist/route-key.js
 /**
@@ -24808,7 +24929,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: {
@@ -24821,6 +24942,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.",
@@ -25102,7 +25239,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).
@@ -25215,6 +25353,7 @@ const INBOX_ITEM_KINDS = [
 	"review_pr",
 	"review_maintenance",
 	"review_policy",
+	"attest_policy",
 	"setup_env_var",
 	"setup_secret",
 	"setup_third_party",
@@ -25524,6 +25663,29 @@ object({
 [...BUILD_RUN_ACTIVE_STATUSES.filter((s) => s !== "reviewing")];
 //#endregion
 //#region ../../packages/types/dist/agents.js
+const AGENT_JOB_TYPES = [
+	"generate_document",
+	"generate_backlog",
+	"plan_backlog_item",
+	"infer_backlog_dependencies",
+	"deploy",
+	"provision_infrastructure",
+	"health_check",
+	"refresh_reality_docs",
+	"derive_policy_update",
+	"derive_design_from_documents",
+	"sync_design_tokens",
+	"generate_design_component",
+	"maintenance_sweep",
+	"maintenance_verify",
+	"propose_ui_concepts",
+	"iterate_ui_concept",
+	"fill_questionnaire",
+	"read_questionnaire_layout",
+	"generate_ui_direction",
+	"assess_policy_conformance",
+	"replan_run"
+];
 /**
 * Why a PROMPTED `generate_backlog` job planned nothing.
 *
@@ -25932,10 +26094,34 @@ 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;
 //#endregion
+//#region ../../packages/types/dist/requests.js
+/** Every way a request can be answered, whatever its kind. */
+const REQUEST_EXITS = [
+	"resume_run",
+	"replan",
+	"clear",
+	"leave_line",
+	"approve",
+	"reject",
+	"merge",
+	"close",
+	"request_changes",
+	"done",
+	"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
 /**
 * Maintenance taxonomy + API DTOs.
@@ -26030,9 +26216,15 @@ 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:")) return typeof finding.baseMove === "boolean" ? finding.baseMove : baseImageMoveRemoves(finding.data);
 	if (finding.kind === "vulnerable_dependency" && isMaliciousPackageFinding(finding)) return true;
 	return isCodeRemediationKind(finding.kind) || !!finding.recommendedVersion;
 }
+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
@@ -26049,6 +26241,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",
@@ -26254,6 +26457,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
@@ -26261,6 +26477,213 @@ 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
+* files (PDFs, Markdown, OpenAPI specs, etc.) indexed into a Bedrock
+* Knowledge Base for retrieval by Taiga's internal agents.
+*/
+const CUSTOM_DOCUMENT_STATUSES = [
+	"pending",
+	"ingesting",
+	"ready",
+	"failed"
+];
+//#endregion
 //#region ../../packages/types/dist/design-tokens.js
 /**
 * The brand grounding contract (PRO-929).
@@ -26436,6 +26859,509 @@ object({
 	fontSize: lenient(union([string$2(), number$1()]))
 });
 //#endregion
+//#region ../../packages/types/dist/questionnaires.js
+/**
+* Questionnaire filling (PRO-932).
+*
+* A customer uploads their own requirement spreadsheet; Taiga answers what the
+* project's evidence settles, cites the document version each answer rests on,
+* and hands back the gaps. The register these types describe is the durable
+* object -- the workbook is an import format on one side and an export format
+* on the other.
+*/
+/**
+* Lifecycle of one questionnaire.
+*
+* `filling` is deliberately NOT set by the fill workflow (PRO-1187), and that
+* is a decision rather than an omission. A status set at the start of a
+* multi-minute run needs something to clear it when the run does not finish --
+* and if the worker dies mid-fill, nothing would: `agent_jobs` has a reaper for
+* stale JOBS, but it knows nothing about this table, so the register would read
+* `filling` forever. A state nothing can leave is worse than one nothing
+* enters.
+*
+* "Is a fill running" is already answerable, and from the row that has a reaper:
+* an active `fill_questionnaire` job with this questionnaire as its target.
+* Wire `filling` up when it comes with a path off it.
+*/
+/**
+* `reading` and `needs_columns` are the import itself (PRO-1506). A workbook
+* is stored and its row exists from the first byte; the column read runs as
+* a job. `reading` is that job in flight; `needs_columns` is the read done
+* without confidence, waiting for a person to confirm the map. Only once the
+* map is confirmed do items exist and the row becomes `draft`.
+*/
+/**
+* A sheet map's bounds, Excel's own: a column index becomes a column letter
+* in a cell reference the export writes to, so an unbounded one names
+* whatever it likes.
+*/
+const EXCEL_MAX_COLUMN = 16384;
+const EXCEL_MAX_ROW = 1048576;
+//#endregion
+//#region ../../packages/types/dist/product-network.js
+/**
+* Where an engineer build's sandbox may connect to (PRO-2793, part of
+* PRO-1980).
+*
+* The engineer pod's credential gateway is the sandbox's only way out. By
+* default it lets through a standard list: the public package registries,
+* toolchain downloads, container registries, GitHub for reading public
+* dependencies, and the tenant's own registries. A product adds to that:
+*
+* - `allowlist` (the default, also what `null` means): the standard list plus
+*   the product's own `networkHosts`.
+* - `unrestricted`: any public host. For a product whose builds need hosts
+*   nobody can list in advance; the gateway still refuses private and
+*   metadata addresses, and still never hands the sandbox a credential.
+*
+* A host is one exact name (`api.example.com`). There are no wildcards: a
+* wildcard over a multi-label public suffix (`*.co.uk`) or a provider's
+* namespace would admit every tenant under it, and telling those apart needs
+* the public suffix list. A build that needs many names under one domain is
+* what `unrestricted` is for.
+*/
+const PRODUCT_NETWORK_ACCESS = ["allowlist", "unrestricted"];
+/**
+* A host a product may add: lowercase DNS labels, at least two, ending in a
+* letter label. No wildcard, scheme, port, path or IP literal.
+*/
+const PRODUCT_NETWORK_HOST_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z][a-z0-9-]{0,61}[a-z0-9]$/;
+/**
+* Domains where anyone can host content under their own name: a bucket, an
+* app, a tunnel. Listing one whole would let a prompt injection send code to
+* a bucket the attacker made, the way the gateway's standard list never lists
+* a shared CDN whole. A specific name under one (`my-bucket.s3.amazonaws.com`)
+* is fine.
+*/
+const SHARED_HOSTING_DOMAINS = [
+	"amazonaws.com",
+	"s3.amazonaws.com",
+	"cloudfront.net",
+	"googleapis.com",
+	"storage.googleapis.com",
+	"appspot.com",
+	"firebaseapp.com",
+	"web.app",
+	"blob.core.windows.net",
+	"azureedge.net",
+	"azurewebsites.net",
+	"githubusercontent.com",
+	"github.io",
+	"herokuapp.com",
+	"vercel.app",
+	"netlify.app",
+	"pages.dev",
+	"workers.dev",
+	"trycloudflare.com",
+	"ngrok.io",
+	"ngrok-free.app",
+	"onrender.com",
+	"fly.dev"
+];
+/** Whether `host` has the shape of a host a product may list. */
+function isProductNetworkHost(host) {
+	return PRODUCT_NETWORK_HOST_PATTERN.test(host);
+}
+/** Whether `host` is a domain anyone can host content on, listed whole. */
+function isSharedHostingDomain(host) {
+	return SHARED_HOSTING_DOMAINS.includes(host);
+}
+strictObject({});
+const uuid = string$2().uuid();
+const sha256 = string$2().regex(/^[0-9a-f]{64}$/, "sha256 must be 64 lowercase hex characters");
+object({ jobId: string$2() });
+/** An upload's grant: a presigned PUT to staging and the headers it signed. */
+const uploadGrant = object({
+	id: string$2(),
+	url: string$2(),
+	headers: record(string$2(), string$2()),
+	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(),
+	fileName: string$2(),
+	error: string$2()
+}));
+object({
+	backlogItemId: string$2(),
+	divergenceCount: number$1(),
+	created: boolean()
+});
+/** The options of a policy fix: build it once planned, and refuse it when the violation was fixed since. */
+const policyFixOptions = {
+	autoBuild: boolean().optional(),
+	refuseIfFixedSinceAssessment: boolean().optional()
+};
+object({
+	findings: number$1(),
+	findingIds: array(string$2()).nullable()
+});
+/** An ignore's expiry, when it has one, is in the future. */
+const expiresInFuture = (expiresAt) => !expiresAt || new Date(expiresAt).getTime() > Date.now();
+const EXPIRY_IN_FUTURE = {
+	message: "The ignore expiry must be in the future.",
+	path: ["ignoreExpiresAt"]
+};
+const ignoreNote = string$2().trim().max(280).nullish();
+const ignoreExpiresAt = string$2().datetime({ offset: true }).nullish();
+const productDocumentType = _enum([...PRODUCT_DOCUMENT_TYPES, LEGACY_PRODUCT_INSTRUCTIONS_TYPE]).transform((type) => type === "project_instructions" ? "product_instructions" : type);
+const customDocumentStatus = _enum(CUSTOM_DOCUMENT_STATUSES);
+const cloudPreferences = object({
+	iacTool: _enum([
+		"terraform",
+		"pulumi",
+		"cdk",
+		"none"
+	]).nullable().optional(),
+	stateBackend: _enum([
+		"aws-s3",
+		"gcs",
+		"azurerm",
+		"tfcloud",
+		"other"
+	]).nullable().optional(),
+	ciSystem: _enum([
+		"github-actions",
+		"gitlab-ci",
+		"circleci",
+		"jenkins",
+		"other"
+	]).nullable().optional(),
+	authMethod: _enum([
+		"oidc",
+		"static-keys",
+		"unknown"
+	]).optional(),
+	accountIsolation: _enum([
+		"per-env",
+		"shared",
+		"unknown"
+	]).optional()
+}).optional();
+const cloudBestPractices = object({
+	dedicatedAccount: boolean().optional(),
+	oidcAuth: boolean().optional(),
+	regionMatchesPolicy: boolean().optional(),
+	stateInSameAccount: boolean().optional()
+}).optional();
+const cloudProviderConfig = discriminatedUnion("provider", [
+	object({
+		provider: literal("aws"),
+		accountId: string$2().regex(/^\d{12}$/, "AWS account ID must be 12 digits").optional(),
+		region: string$2().min(1),
+		preferences: cloudPreferences,
+		bestPractices: cloudBestPractices
+	}),
+	object({
+		provider: literal("gcp"),
+		projectId: string$2().regex(/^[a-z][a-z0-9-]{4,28}[a-z0-9]$/, "Invalid GCP project ID").optional(),
+		region: string$2().min(1),
+		preferences: cloudPreferences,
+		bestPractices: cloudBestPractices
+	}),
+	object({
+		provider: literal("azure"),
+		subscriptionId: string$2().uuid("Azure subscription ID must be a UUID").optional(),
+		tenantId: string$2().uuid("Azure tenant ID must be a UUID").optional(),
+		region: string$2().min(1),
+		preferences: cloudPreferences,
+		bestPractices: cloudBestPractices
+	}),
+	object({
+		provider: literal("upcloud"),
+		zone: string$2().min(1),
+		username: string$2().min(1).optional(),
+		authMethod: _enum(["password", "token"]).optional(),
+		preferences: cloudPreferences,
+		bestPractices: cloudBestPractices
+	})
+]);
+const columnIndex = number$1().int().min(1).max(EXCEL_MAX_COLUMN);
+const sheetMap = object({
+	sheetName: string$2().min(1).max(120),
+	idColumn: columnIndex,
+	questionColumn: columnIndex,
+	detailColumns: array(columnIndex).max(20).optional(),
+	sectionColumn: columnIndex.optional(),
+	answerColumn: columnIndex,
+	justificationColumn: columnIndex.optional(),
+	firstDataRow: number$1().int().min(1).max(EXCEL_MAX_ROW)
+});
+const answerValue = string$2().trim().min(1).max(64);
+const justification = string$2().trim().max(2e3);
+const notApplicableReason = string$2().trim().min(1).max(1200);
+strictObject({ comment: string$2().trim().min(1).max(PLAN_REJECTION_COMMENT_MAX_CHARS) });
+strictObject({ expectedRunId: uuid.optional() }), strictObject({ force: boolean().optional() });
+strictObject({
+	notes: string$2().trim().min(1).max(CHANGE_REQUEST_MAX_CHARS),
+	/** Show the revised plan before the run continues (PRO-3164). */
+	reviewPlan: boolean().optional(),
+	/** The repository whose pull request should change, by its full name, for a run in several (PRO-3346). */
+	repository: string$2().trim().min(1).max(255).optional()
+}), object({ steer: _enum([
+	"replanning",
+	"after_step",
+	"after_round",
+	"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(),
+	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),
+	unknownCitations: object({
+		shown: array(string$2()),
+		count: number$1().int().min(0)
+	})
+}), strictObject({ type: productDocumentType }), strictObject({ type: productDocumentType }), strictObject({}), object({ started: number$1().int().min(0) }), 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(),
+	gitlabProjectId: number$1().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+	provider: _enum(VCS_PROVIDERS).optional().default("github"),
+	repositoryName: string$2().min(1).max(512).optional(),
+	repositoryUrl: string$2().url().max(2048).optional(),
+	repositoryDefaultBranch: string$2().max(255).optional().default("main"),
+	/** The link this one replaces, retired in the same transaction (PRO-2522). */
+	replacesRepositoryId: uuid.optional()
+}).refine((b) => b.gitlabConnectionId === void 0 === (b.gitlabProjectId === void 0), { message: "gitlabConnectionId and gitlabProjectId go together" }).refine((b) => b.gitlabConnectionId === void 0 || b.githubRepositoryId === void 0, { message: "A link is to a GitHub repository or a GitLab project, not both" }).refine((b) => b.githubRepositoryId === void 0 || linksGitHubAppRepositories(b.provider), { message: "githubRepositoryId is a GitHub repository; provider must be github" }), strictObject({
+	repositoryId: uuid,
+	baseBranch: string$2().trim().min(1).max(255).nullable()
+}), object({
+	effectiveBranch: string$2(),
+	protection: object({
+		protected: boolean(),
+		requiredStatusChecks: array(string$2()),
+		enforcementLevel: string$2().nullable()
+	}).nullable()
+}), strictObject({
+	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(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(),
+	priority: number$1().int().min(0).max(99).optional(),
+	metadata: record(string$2(), unknown$1()).optional(),
+	/** Which implementation should serve it (PRO-1332): a request the server may refuse. */
+	runtime: _enum(AGENT_RUNTIMES).optional()
+}), strictObject({
+	fileName: string$2().trim().min(1).max(1024),
+	sizeBytes: number$1().int().nonnegative(),
+	sha256
+}), object({ upload: uploadGrant }), strictObject({ uploadId: uuid }), object({
+	questionnaireId: string$2(),
+	jobId: string$2()
+}), strictObject({ mode: _enum(["generate", "republish"]).default("generate") }), strictObject({ docTypes: array(_enum(REALITY_DERIVED_DOCUMENT_TYPES)).min(1).max(REALITY_DERIVED_DOCUMENT_TYPES.length).optional() }), object({ jobIds: array(string$2()) }), object({ cancelledJobIds: array(string$2()) }), strictObject({
+	factoryId: uuid,
+	stopLine: boolean().optional()
+}), object({
+	changed: boolean(),
+	previousFactoryId: string$2().nullable(),
+	lineStopped: boolean(),
+	failedDocuments,
+	/** How many uploads kept the old factory; null while not known, never read as none. */
+	failedCount: number$1().int().min(0).nullable()
+}), strictObject({ documentIds: array(uuid).min(1).max(100).optional() }), object({
+	rescopedCount: number$1().int().min(0).nullable(),
+	failedDocuments,
+	failedCount: number$1().int().min(0).nullable()
+}), strictObject({ repositoryId: uuid }), strictObject({
+	ecosystem: string$2().min(1).max(50),
+	packageName: string$2().min(1).max(255),
+	/** The installed version, for a package resolved at several in a monorepo. */
+	currentVersion: string$2().min(1).max(100).nullish(),
+	/** The linked repository the group belongs to: a fix touches one. */
+	productRepositoryId: uuid.nullish(),
+	/** Build the fix as soon as it is planned (PRO-949). */
+	autoBuild: boolean().optional()
+}), object({
+	backlogItemId: string$2(),
+	findingCount: number$1()
+}), strictObject({
+	...policyFixOptions,
+	controlId: string$2().min(1).max(40)
+}), 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"]) }), 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"]
+	}),
+	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"),
+		type: _enum(ENVIRONMENT_TYPES),
+		ordinal: number$1().int().min(0).default(0),
+		isProtected: boolean().default(false)
+	}).optional()
+});
+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()
+});
+/** 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 });
+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({
+	applied: _enum([
+		"draft",
+		"published",
+		"declined"
+	]),
+	version: number$1().int().nullable()
+}), strictObject({
+	fileName: string$2().trim().min(1).max(255),
+	mime: string$2().min(1).max(255),
+	sizeBytes: number$1().int().positive(),
+	sha256,
+	factoryId: string$2().optional(),
+	productId: string$2().optional(),
+	origin: string$2().optional()
+}), discriminatedUnion("deduplicated", [object({
+	deduplicated: literal(true),
+	documentId: string$2(),
+	factoryId: string$2().nullable(),
+	status: customDocumentStatus
+}), object({
+	deduplicated: literal(false),
+	upload: uploadGrant
+})]), strictObject({ uploadId: uuid }), object({
+	documentId: string$2(),
+	factoryId: string$2().nullable(),
+	deduplicated: boolean(),
+	status: customDocumentStatus.nullable(),
+	/** Filing it threw; absent when it went through. */
+	error: string$2().optional()
+}), strictObject({ ids: array(uuid).min(1).max(100) }), object({
+	failedIds: array(string$2()).nullable(),
+	deletedIds: array(string$2()).optional()
+}), 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() }), 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()
+});
+strictObject({ kind: _enum(["sbom", "notices"]) }), object({
+	url: string$2().url().nullable(),
+	expiresAt: string$2().nullable()
+});
+strictObject({
+	ignoreReason: _enum(MAINTENANCE_IGNORE_REASONS),
+	ignoreNote,
+	ignoreExpiresAt
+}).refine((args) => expiresInFuture(args.ignoreExpiresAt), EXPIRY_IN_FUTURE), strictObject({ autoBuild: boolean().optional() }), object({ backlogItemId: string$2() });
+strictObject(policyFixOptions);
+strictObject({ tier: _enum([
+	"development",
+	"staging",
+	"production"
+]) });
+object({
+	url: string$2().url(),
+	expiresAt: string$2(),
+	written: number$1(),
+	unwrittenCount: number$1(),
+	summary: object({
+		byTaiga: number$1(),
+		byYou: number$1(),
+		notApplicable: number$1(),
+		blank: number$1()
+	})
+}), strictObject({
+	columnMap: object({ sheets: array(sheetMap).min(1).max(50) }),
+	answerVocabulary: array(string$2().min(1).max(64)).max(16).nullable().optional(),
+	answerLegend: string$2().max(4e3).nullable().optional()
+}), object({
+	imported: number$1(),
+	skippedRows: number$1()
+});
+discriminatedUnion("action", [
+	strictObject({ action: literal("accept") }),
+	strictObject({ action: literal("reject") }),
+	strictObject({
+		action: literal("edit"),
+		answerValue: answerValue.optional(),
+		justification: justification.optional()
+	}),
+	strictObject({
+		action: literal("answer"),
+		answerValue,
+		justification: justification.optional()
+	}),
+	strictObject({
+		action: literal("not_applicable"),
+		/** The token the form uses for it, when it has one -- `NA`, `N/A`, `es`. */
+		answerValue: answerValue.optional(),
+		reason: notApplicableReason
+	})
+]);
+//#endregion
 //#region ../../packages/types/dist/auto-build.js
 /**
 * Auto-build: the review-plans gate (PRO-1305).
@@ -26520,30 +27446,6 @@ Object.freeze({
 	applicationOwnership: true
 });
 //#endregion
-//#region ../../packages/types/dist/product-network.js
-/**
-* Where an engineer build's sandbox may connect to (PRO-2793, part of
-* PRO-1980).
-*
-* The engineer pod's credential gateway is the sandbox's only way out. By
-* default it lets through a standard list: the public package registries,
-* toolchain downloads, container registries, GitHub for reading public
-* dependencies, and the tenant's own registries. A product adds to that:
-*
-* - `allowlist` (the default, also what `null` means): the standard list plus
-*   the product's own `networkHosts`.
-* - `unrestricted`: any public host. For a product whose builds need hosts
-*   nobody can list in advance; the gateway still refuses private and
-*   metadata addresses, and still never hands the sandbox a credential.
-*
-* A host is one exact name (`api.example.com`). There are no wildcards: a
-* wildcard over a multi-label public suffix (`*.co.uk`) or a provider's
-* namespace would admit every tenant under it, and telling those apart needs
-* the public suffix list. A build that needs many names under one domain is
-* what `unrestricted` is for.
-*/
-const PRODUCT_NETWORK_ACCESS = ["allowlist", "unrestricted"];
-//#endregion
 //#region src/compat.ts
 /**
 * Why this server should not serve the API it reached, or null when it may
@@ -26611,6 +27513,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",
@@ -26635,6 +27538,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",
@@ -26664,6 +27568,40 @@ const TOOLSET_OF = {
 	taiga_retry_knowledge: "documents"
 };
 /**
+* Deliver & Operate's tools (PRO-3834): initiatives, plans, runs and the line, fixes, environments, deployments,
+* monitoring and delivery metrics. An organization whose plan refuses delivery work does not see them, as its web app
+* shows none of their views; the API says which (`deliveryIncluded` at introspection), so the plan, not the key,
+* decides. Fixing a finding plans and builds, so it goes with them.
+*/
+const DELIVERY_TOOLS = /* @__PURE__ */ new Set([
+	"taiga_list_initiatives",
+	"taiga_get_initiative",
+	"taiga_get_plan",
+	"taiga_list_runs",
+	"taiga_get_run",
+	"taiga_get_line",
+	"taiga_queue_initiative",
+	"taiga_move_initiative",
+	"taiga_review_plan",
+	"taiga_plan_again",
+	"taiga_resume_initiative",
+	"taiga_stop_run",
+	"taiga_request_changes",
+	"taiga_request_initiatives",
+	"taiga_fix_finding",
+	"taiga_fix_policy_violation",
+	"taiga_ship_notices",
+	"taiga_set_auto_build",
+	"taiga_set_auto_merge",
+	"taiga_pause_line",
+	"taiga_create_environment",
+	"taiga_update_environment",
+	"taiga_get_deployments",
+	"taiga_get_monitoring",
+	"taiga_get_delivery_metrics",
+	"taiga_sync_design_tokens"
+]);
+/**
 * TAIGA_TOOLSETS as written: comma-separated names, or "all"; a name it does not know is said, not ignored, and so
 * is a value that names none.
 */
@@ -26894,7 +27832,7 @@ function setupNextStep(product) {
 	if (isImportedProduct(product)) switch (importStatusOf(product)) {
 		case "analyzing":
 		case "generating_docs": return `The import is running and derives the documents from the code (taiga_wait (jobId) follows its job). Then review them, and ${FINISH_DISCOVERY}`;
-		case "complete": return "The import is done: review the reality documents (taiga_get_product_document without type), then taiga_finish_discovery opens the product and starts planning its first initiatives (paid agent work: ask the person first).";
+		case "complete": return "The import is done: review the reality documents (taiga_get_product_document without type), then " + FINISH_DISCOVERY;
 		case "failed":
 		case "cancelled": return "The last import did not finish: taiga_start_import runs it again.";
 		default: return "Link its repository if it has none (taiga_list_linkable_repositories, taiga_link_repository), then taiga_start_import: the import derives the documents from the code and runs by itself.";
@@ -26902,7 +27840,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}`;
 	}
 }
@@ -26931,8 +27868,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.",
@@ -27409,6 +28354,8 @@ const PACKAGE_ROW_FIELDS = [
 	"scopeReason",
 	"parentReason",
 	"sourcePath",
+	"baseImage",
+	"imageLayer",
 	"productRepositoryId",
 	"detectedAt"
 ];
@@ -27430,7 +28377,10 @@ const FINDING_ROW_FIELDS = [
 	"tier",
 	"kevListedAt",
 	"malicious",
+	"baseMove",
+	"baseImageMove",
 	"removal",
+	"replaceable",
 	"status",
 	"title",
 	"ecosystem",
@@ -27559,11 +28509,19 @@ function withFixability(row) {
 			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."
 		};
 	}
-	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,
@@ -27587,14 +28545,37 @@ function withFixability(row) {
 		fixable: true,
 		fixNote: "A malicious package: taiga_fix_finding removes it (or replaces it), with every advisory on that version."
 	} : row;
+	if (typeof row["baseMove"] === "boolean" && isAgentRemediable({ remediableBy: typeof row["remediableBy"] === "string" ? row["remediableBy"] : null })) 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,
-		fixNote: "No fixed version is known yet: taiga_fix_finding refuses it until one is published."
+		fixNote: noVersionNote(row["data"])
 	};
 	return row;
 }
 /**
+* Why a dependency has no version to move to. A language runtime declared as
+* a container image moves only to a release the image has published
+* (PRO-3729), so its vendor's fix can be out while Fix is refused: the
+* finding's runtime data says so where the row carries it (taiga_get_finding).
+*/
+function noVersionNote(data) {
+	const runtime = data?.runtime;
+	const fixedIn = typeof runtime?.["fixedIn"] === "string" ? runtime["fixedIn"] : null;
+	if (fixedIn) return `Fixed in ${fixedIn}, but there is no release to move to yet: the image the repository declares has not published it, or, where the line has ended, a supported line (the summary says which). taiga_fix_finding refuses it until there is one.`;
+	if (runtime && (typeof runtime["newest"] === "string" || "endOfLife" in runtime)) return "A newer release is out, but the image the repository declares has not published one to move to yet (the summary names the image): taiga_fix_finding refuses it until it does.";
+	if (runtime) return "No fixed release is known yet, or, where the line has ended, the image the repository declares has not published a supported line (the summary says which): taiga_fix_finding refuses it until there is one.";
+	return "No version to move to yet: no fixed version is known, or for a language runtime the image the repository declares has not published one (taiga_get_finding says which). taiga_fix_finding refuses it until there is one.";
+}
+/**
 * Dev-only, runtime or unknown, said on a dependency row (PRO-2861) in place of the raw per-lockfile groups
 * the API carries: the groups need the lockfile name to read, which `dependencyScope` does once here.
 */
@@ -27650,7 +28631,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. */
@@ -27691,6 +28675,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",
@@ -27747,11 +28761,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,
@@ -27759,6 +28813,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",
@@ -27846,10 +28914,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.",
@@ -27916,7 +28992,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),
@@ -27939,6 +29016,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.` } : {}
@@ -27962,7 +29040,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;
@@ -27988,9 +29067,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. Refused when no fixed version is known (fixable: false), 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,
@@ -28029,6 +29130,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
@@ -28354,20 +29462,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
 		})
 	};
@@ -28389,7 +29494,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
@@ -29473,7 +30577,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) {
@@ -30231,6 +31336,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,
@@ -30238,7 +31347,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. */
@@ -30421,7 +31531,8 @@ const PLAN_SUMMARY_FIELDS = [
 	"backlogItemId",
 	"version",
 	"status",
-	"createdAt"
+	"createdAt",
+	"controls"
 ];
 const PLAN_STEP_SUMMARY_FIELDS = [
 	"id",
@@ -30568,10 +31679,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)
 		});
 	}));
 }
@@ -31527,7 +32640,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
@@ -48294,7 +49407,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 () => {
@@ -48338,6 +49451,7 @@ function withStrictInputs(server, client, registered, toolsets, left) {
 	const inputs = /* @__PURE__ */ new Map();
 	const register = server.registerTool.bind(server);
 	server.registerTool = ((name, config, callback) => {
+		if (DELIVERY_TOOLS.has(name) && client.getIntrospection()?.deliveryIncluded === false) return void 0;
 		const toolset = TOOLSET_OF[name];
 		if (name !== "taiga_whoami") {
 			if (!toolset) throw new Error(`Tool ${name}: no toolset in toolsets.ts`);
@@ -48558,6 +49672,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",