@taiga-ai/mcp-server 0.25.0-dev.471 → 0.25.0-dev.475

package/dist/index.js

@@ -356,11 +356,11 @@ var TaigaClient = class {
 	async getPolicyStanding(productId) {
 		return this.request("GET", `/products/${seg(productId)}/maintenance/policies`);
 	}
-	async remediatePolicyControl(productId, controlId) {
-		return this.request("POST", `/products/${seg(productId)}/maintenance/policies/controls/${seg(controlId)}/remediate`, {});
+	async remediatePolicyControl(productId, controlId, body = {}) {
+		return this.request("POST", `/products/${seg(productId)}/maintenance/policies/controls/${seg(controlId)}/remediate`, body);
 	}
-	async remediatePolicyViolation(productId, divergenceId) {
-		return this.request("POST", `/products/${seg(productId)}/maintenance/policies/divergences/${seg(divergenceId)}/remediate`, {});
+	async remediatePolicyViolation(productId, divergenceId, body = {}) {
+		return this.request("POST", `/products/${seg(productId)}/maintenance/policies/divergences/${seg(divergenceId)}/remediate`, body);
 	}
 	async listInbox(opts) {
 		const { productId, ...rest } = opts;
@@ -2256,6 +2256,11 @@ function emptyOriginNote(origin, product) {
 	}
 }
 /**
+* What finishing does, in every next step that ends at it (PRO-2857): it
+* starts paid planning, so a client must ask the person before calling it.
+*/
+const FINISH_DISCOVERY = "taiga_finish_discovery opens the product and starts planning its first initiatives (paid agent work: ask the person first).";
+/**
 * What a product in setup waits for, as the next call to make. Nothing on a
 * draft product says it otherwise: discoveryStep names the step and
 * importStatus the import, and the way on from each lives in tool
@@ -2266,17 +2271,17 @@ function setupNextStep(product) {
 	if (product?.status !== "draft") return null;
 	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_for_job follows its job). Then review them, and taiga_finish_discovery opens the product.";
-		case "complete": return "The import is done: review the reality documents (taiga_get_product_document without type), then taiga_finish_discovery opens the product.";
+		case "generating_docs": return `The import is running and derives the documents from the code (taiga_wait_for_job 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 "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.";
 	}
 	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, taiga_finish_discovery opens the product.";
-		case "checks": return "The documents are published; the checks are stamped in the web, then taiga_finish_discovery opens the product.";
-		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 taiga_finish_discovery opens the product.";
+		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}`;
 	}
 }
 /** What discoveryStep says, for a description that shows it. */
@@ -2823,7 +2828,7 @@ async function setupReadiness(client, product, links) {
 	};
 }
 function nextStepFor(state) {
-	const finish = "taiga_finish_discovery opens the product and locks its documents (ask the person: it is their decision that the documents are right).";
+	const finish = "taiga_finish_discovery opens the product, locks its documents and starts planning the first initiatives (paid agent work; ask the person: it is their decision that the documents are right).";
 	if (state.imported) {
 		if (state.linked === false) return "Link its repository (taiga_list_linkable_repositories, then taiga_link_repository), then taiga_start_import.";
 		if (state.linked === null && state.importState === "not started") return setupNextStep(state.product);
@@ -4284,6 +4289,7 @@ function situationOf(item) {
 		const handback = handbackSaid(build.reviewEscalation);
 		if (handback) stage += `, handed back because ${handback}`;
 	}
+	if (life.stage === "done" || life.stage === "canceled") stage += endingSaid(item);
 	parts.push(`${stage}.`);
 	if (typeof item["needsHumanCause"] === "string") {
 		const why = [renderHalt({
@@ -4301,6 +4307,26 @@ function situationOf(item) {
 	else if (move) parts.push(`Next: ${move}.`);
 	return parts.join(" ");
 }
+/**
+* How a settled initiative ended, as the rest of its "Done" or "Canceled"
+* sentence (PRO-2821): the pull request that landed it, the move that settled
+* it and who made it, and what took over. Only the single read carries
+* `ending`; a list row says nothing more.
+*/
+function endingSaid(item) {
+	const ending = item["ending"];
+	const merged = typeof ending?.landedPr?.number === "number" ? ending.landedPr.number : null;
+	const said = [];
+	if (merged !== null) said.push(`: PR #${merged} merged`);
+	else if (ending && (ending.via === "moved" || ending.via === "off_the_line")) {
+		const who = typeof ending.by?.name === "string" ? ending.by.name : ending.by?.type === "system" ? "Taiga" : "someone";
+		const when = typeof ending.at === "string" ? ` on ${ending.at.slice(0, 10)}` : "";
+		said.push(ending.via === "off_the_line" ? ` by ${who}${when}, who took it off the line` : ` by ${who}${when}`);
+	}
+	const next = ending?.supersededBy;
+	if (next && typeof next.id === "string") said.push(`; superseded by "${String(next.title)}" (${next.id})`);
+	return said.join("");
+}
 /** A row or item with its situation added when it has a lifecycle. */
 function withSituation(item, row = item) {
 	const situation = situationOf(item);
@@ -5018,16 +5044,18 @@ function registerMaintenanceTools(server, client) {
 	}));
 	server.registerTool("taiga_fix_policy_violation", {
 		title: "Fix policy violations",
-		description: "Raise one initiative that fixes a product's policy violations and add it to the end of the line. Name a control to cover all its violations with no initiative yet, or one violationId when the control has several. The violation stays listed until the next assessment no longer finds it, even while the fix is under way.",
+		description: "Raise one initiative that fixes a product's policy violations and add it to the end of the line. Name a control to cover all its violations with no initiative yet, or one violationId when the control has several. The violation stays listed until the next assessment no longer finds it, even while the fix is under way. A violation whose last fix was done after it was last assessed is refused: refresh the reality documents to reassess it first, or pass fixAgain: true if the person wants another fix anyway.",
 		inputSchema: z.object({
 			productId,
 			controlId: z.string().min(1).max(40).optional().describe("The control's identifier, e.g. SEC-3.4"),
-			violationId: idInput("violation", "taiga_get_policy_standing gives it").optional()
+			violationId: idInput("violation", "taiga_get_policy_standing gives it").optional(),
+			fixAgain: z.boolean().optional().describe("Raise a fix even though the last one was done after the last assessment (default false)")
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
 		if (params.controlId === void 0 === (params.violationId === void 0)) return toolError("VALIDATION_ERROR", "Name either a control (controlId) or one violation (violationId), not both or neither.");
-		return toolResult((params.controlId ? await client.remediatePolicyControl(params.productId, params.controlId) : await client.remediatePolicyViolation(params.productId, params.violationId)).data);
+		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);
 	}));
 }
 //#endregion
@@ -21649,7 +21677,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 Discovery: it locks the documents and opens the rest of the product; for an imported product the first initiatives are planned. Refused (CONFLICT) with details.reason: documents_incomplete (details.missingDocuments lists them and how they are made), not_in_setup (already finished), or a required check not yet stamped (stamped in the web). A locked document changes only after taiga_reopen_discovery. The person decides the documents are right: ask first.",
+		description: "Finish a product's Discovery: it locks the documents, opens the rest of the product and starts planning the first initiatives (paid agent work; an imported product plans once its scan and policy assessment settle). Refused (CONFLICT) with details.reason: documents_incomplete (details.missingDocuments lists them and how they are made), not_in_setup (already finished), or a required check not yet stamped (stamped in the web). A locked document changes only after taiga_reopen_discovery. The person decides the documents are right: ask first.",
 		inputSchema: z.object({ productId }),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.25.0-dev.471",
+  "version": "0.25.0-dev.475",
   "description": "MCP server for Taiga -- gives AI assistants access to documents and products",
   "type": "module",
   "main": "./dist/index.js",

package/src/client.ts

@@ -31,6 +31,7 @@ import type {
   MonitoringHistory,
   MoveProductResult,
   PolicyConformance,
+  PolicyRemediationInput,
   PolicyRemediationResult,
   Product,
   ProductDocument,
@@ -647,19 +648,19 @@ export class TaigaClient {
     return this.request<One<PolicyConformance>>('GET', `/products/${seg(productId)}/maintenance/policies`);
   }
 
-  async remediatePolicyControl(productId: string, controlId: string) {
+  async remediatePolicyControl(productId: string, controlId: string, body: PolicyRemediationInput = {}) {
     return this.request<One<PolicyRemediationResult>>(
       'POST',
       `/products/${seg(productId)}/maintenance/policies/controls/${seg(controlId)}/remediate`,
-      {}
+      body
     );
   }
 
-  async remediatePolicyViolation(productId: string, divergenceId: string) {
+  async remediatePolicyViolation(productId: string, divergenceId: string, body: PolicyRemediationInput = {}) {
     return this.request<One<PolicyRemediationResult>>(
       'POST',
       `/products/${seg(productId)}/maintenance/policies/divergences/${seg(divergenceId)}/remediate`,
-      {}
+      body
     );
   }
 

package/src/server.integration.test.ts

@@ -5189,7 +5189,7 @@ describe('MCP server integration', () => {
       );
       await client.callTool({
         name: 'taiga_fix_policy_violation',
-        arguments: { productId: PRODUCT_ID, violationId: VIOLATION_ID },
+        arguments: { productId: PRODUCT_ID, violationId: VIOLATION_ID, fixAgain: true },
       });
       const both = await client.callTool({
         name: 'taiga_fix_policy_violation',
@@ -5201,6 +5201,19 @@ describe('MCP server integration', () => {
         `/v1/products/${PRODUCT_ID}/maintenance/policies/controls/SEC-3.4/remediate`,
         `/v1/products/${PRODUCT_ID}/maintenance/policies/divergences/${VIOLATION_ID}/remediate`,
       ]);
+      // An unassessed last fix is refused unless the person wants another (PRO-2821).
+      expect(
+        sentBody(fetchSpy, 'POST', `/v1/products/${PRODUCT_ID}/maintenance/policies/controls/SEC-3.4/remediate`)
+      ).toEqual({
+        refuseIfFixedSinceAssessment: true,
+      });
+      expect(
+        sentBody(
+          fetchSpy,
+          'POST',
+          `/v1/products/${PRODUCT_ID}/maintenance/policies/divergences/${VIOLATION_ID}/remediate`
+        )
+      ).toEqual({ refuseIfFixedSinceAssessment: false });
       expect(both.isError).toBe(true);
     });
 
@@ -7683,6 +7696,132 @@ describe('what the third agent review found (PRO-2800)', () => {
     expect(runs[3]).toHaveProperty('prDraft', true);
   });
 
+  it('says how a settled initiative ended: the merged PR, who canceled it and what took over (PRO-2821)', async () => {
+    const NEXT = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4f21';
+    const canceled = {
+      id: ITEM_ID,
+      title: 'SDLC-3.5: No secret detection',
+      status: 'canceled',
+      state: 'canceled',
+      needsHumanCause: null,
+      lifecycle: { turn: null, stage: 'canceled', cta: null, planFailureCause: null, latestBuild: null },
+      ending: {
+        status: 'canceled',
+        via: 'off_the_line',
+        at: '2026-10-08T05:36:08.000Z',
+        by: { type: 'user', id: 'u1', name: 'Riley' },
+        landedPr: null,
+        supersededBy: { id: NEXT, title: 'SDLC-3.5: No secret detection' },
+      },
+    };
+    const done = {
+      id: NEXT,
+      title: 'SDLC-3.5: No secret detection',
+      status: 'done',
+      state: 'done',
+      needsHumanCause: null,
+      lifecycle: {
+        turn: null,
+        stage: 'done',
+        cta: 'view_pr',
+        planFailureCause: null,
+        latestBuild: { status: 'completed', prNumber: 20, prMerged: true },
+      },
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['backlog:read'],
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: canceled },
+        [`/v1/products/${PRODUCT_ID}/backlog`]: { data: [done], nextCursor: null },
+      },
+    });
+
+    const got = parseToolResult(
+      await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+    );
+    const listed = parseToolResult(
+      await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: PRODUCT_ID, status: 'all' } })
+    );
+
+    expect(got.situation).toBe(
+      `Canceled by Riley on 2026-10-08, who took it off the line; superseded by "SDLC-3.5: No secret detection" (${NEXT}).`
+    );
+    // A list row has no ending: its latest run cannot say how it ended.
+    expect(listed.data[0].situation).toMatch(/^Done\./);
+    expect(listed.data[0].situation).not.toMatch(/merged/);
+  });
+
+  it('names the pull request a merge landed on the single read (PRO-2821)', async () => {
+    const done = {
+      id: ITEM_ID,
+      title: 'Add login',
+      status: 'done',
+      state: 'done',
+      needsHumanCause: null,
+      lifecycle: { turn: null, stage: 'done', cta: 'view_pr', planFailureCause: null, latestBuild: null },
+      ending: {
+        status: 'done',
+        via: 'merged',
+        at: null,
+        by: null,
+        landedPr: { number: 20, url: 'https://x/20' },
+        supersededBy: null,
+      },
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['backlog:read'],
+      routes: { [`GET /v1/backlog/${ITEM_ID}`]: { data: done } },
+    });
+
+    const got = parseToolResult(
+      await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+    );
+
+    expect(got.situation).toMatch(/^Done: PR #20 merged\./);
+  });
+
+  it('does not read a merge into a canceled initiative that kept its merged run (PRO-2821)', async () => {
+    const item = {
+      id: ITEM_ID,
+      title: 'Add login',
+      status: 'canceled',
+      state: 'canceled',
+      needsHumanCause: null,
+      lifecycle: {
+        turn: null,
+        stage: 'canceled',
+        cta: null,
+        planFailureCause: null,
+        latestBuild: { status: 'completed', prNumber: 20, prMerged: true },
+      },
+    };
+    const ending = {
+      status: 'canceled',
+      via: 'moved',
+      at: '2026-10-09T10:00:00.000Z',
+      by: { type: 'user', name: 'Riley' },
+      landedPr: null,
+      supersededBy: null,
+    };
+    const { client } = await bootMcpPair({
+      capabilities: ['backlog:read'],
+      routes: {
+        [`GET /v1/backlog/${ITEM_ID}`]: { data: { ...item, ending } },
+        [`/v1/products/${PRODUCT_ID}/backlog`]: { data: [item], nextCursor: null },
+      },
+    });
+
+    const got = parseToolResult(
+      await client.callTool({ name: 'taiga_get_initiative', arguments: { initiativeId: ITEM_ID } })
+    );
+    const listed = parseToolResult(
+      await client.callTool({ name: 'taiga_list_initiatives', arguments: { productId: PRODUCT_ID, status: 'all' } })
+    );
+
+    expect(got.situation).toBe('Canceled by Riley on 2026-10-09.');
+    expect(listed.data[0].situation).toBe('Canceled.');
+  });
+
   it('says where an initiative stands and the call that moves it on, in one sentence', async () => {
     const item = {
       id: ITEM_ID,

package/src/tools/backlogs.ts

@@ -134,6 +134,7 @@ export function situationOf(item: Record<string, unknown>): string | null {
     const handback = handbackSaid((build as { reviewEscalation?: unknown }).reviewEscalation);
     if (handback) stage += `, handed back because ${handback}`;
   }
+  if (life.stage === 'done' || life.stage === 'canceled') stage += endingSaid(item);
   parts.push(`${stage}.`);
   if (typeof item['needsHumanCause'] === 'string') {
     const halt = renderHalt({ cause: item['needsHumanCause'], params: {} } as unknown as Halt);
@@ -160,6 +161,41 @@ export function situationOf(item: Record<string, unknown>): string | null {
   return parts.join(' ');
 }
 
+/**
+ * How a settled initiative ended, as the rest of its "Done" or "Canceled"
+ * sentence (PRO-2821): the pull request that landed it, the move that settled
+ * it and who made it, and what took over. Only the single read carries
+ * `ending`; a list row says nothing more.
+ */
+function endingSaid(item: Record<string, unknown>) {
+  const ending = item['ending'] as
+    | {
+        via?: unknown;
+        at?: unknown;
+        by?: { name?: unknown; type?: unknown } | null;
+        landedPr?: { number?: unknown } | null;
+        supersededBy?: { id?: unknown; title?: unknown } | null;
+      }
+    | null
+    | undefined;
+  // The single read's ending decides. A list row has none, and its latest run cannot say how it ended: a merged
+  // initiative can be reopened and moved to Done by hand, keeping that run. It says Done or Canceled alone.
+  const merged = typeof ending?.landedPr?.number === 'number' ? ending.landedPr.number : null;
+  const said: string[] = [];
+  if (merged !== null) said.push(`: PR #${merged} merged`);
+  else if (ending && (ending.via === 'moved' || ending.via === 'off_the_line')) {
+    const who =
+      typeof ending.by?.name === 'string' ? ending.by.name : ending.by?.type === 'system' ? 'Taiga' : 'someone';
+    const when = typeof ending.at === 'string' ? ` on ${ending.at.slice(0, 10)}` : '';
+    said.push(ending.via === 'off_the_line' ? ` by ${who}${when}, who took it off the line` : ` by ${who}${when}`);
+  }
+  const next = ending?.supersededBy;
+  if (next && typeof next.id === 'string') {
+    said.push(`; superseded by "${String(next.title)}" (${next.id})`);
+  }
+  return said.join('');
+}
+
 /** A row or item with its situation added when it has a lifecycle. */
 export function withSituation(
   item: Record<string, unknown>,

package/src/tools/catalogue.ts

@@ -161,6 +161,13 @@ export function emptyOriginNote(
   }
 }
 
+/**
+ * What finishing does, in every next step that ends at it (PRO-2857): it
+ * starts paid planning, so a client must ask the person before calling it.
+ */
+const FINISH_DISCOVERY =
+  'taiga_finish_discovery opens the product and starts planning its first initiatives (paid agent work: ask the person first).';
+
 /**
  * What a product in setup waits for, as the next call to make. Nothing on a
  * draft product says it otherwise: discoveryStep names the step and
@@ -178,12 +185,12 @@ export function setupNextStep(
       case 'generating_docs':
         return (
           'The import is running and derives the documents from the code (taiga_wait_for_job follows its job). ' +
-          'Then review them, and taiga_finish_discovery opens the product.'
+          `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.'
+          FINISH_DISCOVERY
         );
       case 'failed':
       case 'cancelled':
@@ -204,14 +211,14 @@ export function setupNextStep(
       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, taiga_finish_discovery opens the product.'
+        `published, ${FINISH_DISCOVERY}`
       );
     case 'checks':
-      return 'The documents are published; the checks are stamped in the web, then taiga_finish_discovery opens the product.';
+      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 taiga_finish_discovery opens the product.'
+        `specification comes out of it. The other documents follow, then ${FINISH_DISCOVERY}`
       );
   }
 }

package/src/tools/maintenance.ts

@@ -515,11 +515,16 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
         "Raise one initiative that fixes a product's policy violations and add it to the end of the line. Name a " +
         'control to cover all its violations with no initiative yet, or one violationId when the control has ' +
         'several. The violation stays listed until the next assessment no longer finds it, even while the fix is ' +
-        'under way.',
+        'under way. A violation whose last fix was done after it was last assessed is refused: refresh the ' +
+        'reality documents to reassess it first, or pass fixAgain: true if the person wants another fix anyway.',
       inputSchema: z.object({
         productId,
         controlId: z.string().min(1).max(40).optional().describe("The control's identifier, e.g. SEC-3.4"),
         violationId: idInput('violation', 'taiga_get_policy_standing gives it').optional(),
+        fixAgain: z
+          .boolean()
+          .optional()
+          .describe('Raise a fix even though the last one was done after the last assessment (default false)'),
       }),
       annotations: OPERATE,
     },
@@ -531,9 +536,11 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
             'Name either a control (controlId) or one violation (violationId), not both or neither.'
           );
         }
+        // The API refuses a violation whose last fix is unassessed, unless the person wants another (PRO-2821).
+        const body = { refuseIfFixedSinceAssessment: params.fixAgain !== true };
         const result = params.controlId
-          ? await client.remediatePolicyControl(params.productId, params.controlId)
-          : await client.remediatePolicyViolation(params.productId, params.violationId!);
+          ? await client.remediatePolicyControl(params.productId, params.controlId, body)
+          : await client.remediatePolicyViolation(params.productId, params.violationId!, body);
         return toolResult(result.data);
       })
   );

package/src/tools/readiness.ts

@@ -127,8 +127,8 @@ function nextStepFor(state: {
   product: Row;
 }): string | null {
   const finish =
-    'taiga_finish_discovery opens the product and locks its documents (ask the person: it is their decision ' +
-    'that the documents are right).';
+    'taiga_finish_discovery opens the product, locks its documents and starts planning the first initiatives ' +
+    '(paid agent work; ask the person: it is their decision that the documents are right).';
   if (state.imported) {
     if (state.linked === false) {
       return 'Link its repository (taiga_list_linkable_repositories, then taiga_link_repository), then taiga_start_import.';

package/src/tools/setup.ts

@@ -386,8 +386,9 @@ export function registerSetupTools(server: McpServer, client: TaigaClient) {
     {
       title: 'Finish Discovery',
       description:
-        "Finish a product's Discovery: it locks the documents and opens the rest of the product; for an imported " +
-        'product the first initiatives are planned. Refused (CONFLICT) with details.reason: documents_incomplete ' +
+        "Finish a product's Discovery: it locks the documents, opens the rest of the product and starts planning " +
+        'the first initiatives (paid agent work; an imported product plans once its scan and policy assessment ' +
+        'settle). Refused (CONFLICT) with details.reason: documents_incomplete ' +
         '(details.missingDocuments lists them and how they are made), not_in_setup (already finished), or a ' +
         'required check not yet stamped (stamped in the web). A locked document changes only after ' +
         'taiga_reopen_discovery. The person decides the documents are right: ask first.',