@taiga-ai/mcp-server 0.18.0-dev.447 → 0.18.0-dev.449

package/src/tools/knowledge.ts

@@ -15,8 +15,6 @@ import { page, pickFields } from './summarize.js';
  * admin, which the API enforces.
  */
 
-type Row = Record<string, unknown>;
-
 const KNOWLEDGE_FIELDS = [
   'id',
   'factoryId',
@@ -123,7 +121,7 @@ export function registerKnowledgeTools(server: McpServer, client: TaigaClient) {
             ? { factoryId: params.factoryId, productId: null }
             : { factoryId: null, productId: null };
         const result = await client.listKnowledge({ ...scope, limit: params.limit, cursor: params.cursor });
-        return toolResult(page(pickFields(result.data as Row[], KNOWLEDGE_FIELDS), result.nextCursor));
+        return toolResult(page(pickFields(result.data, KNOWLEDGE_FIELDS), result.nextCursor));
       })
   );
 
@@ -143,7 +141,7 @@ export function registerKnowledgeTools(server: McpServer, client: TaigaClient) {
     (params) =>
       runTool(async () => {
         const file = await client.getKnowledge(params.knowledgeId);
-        const row = pickFields([file.data as Row], KNOWLEDGE_FIELDS)[0]!;
+        const row = pickFields([file.data], KNOWLEDGE_FIELDS)[0]!;
         if (row.status !== 'ready') {
           return toolResult({
             ...row,
@@ -213,7 +211,7 @@ export function registerKnowledgeTools(server: McpServer, client: TaigaClient) {
         // there: the flag says so, so that file is not taken for a new one
         // (and deleted as one in a clean-up).
         return toolResult({
-          ...pickFields([result.data as Row], KNOWLEDGE_FIELDS)[0],
+          ...pickFields([result.data], KNOWLEDGE_FIELDS)[0],
           deduplicated: result.deduplicated === true,
         });
       })
@@ -231,7 +229,7 @@ export function registerKnowledgeTools(server: McpServer, client: TaigaClient) {
     },
     (params) =>
       runTool(async () =>
-        toolResult(pickFields([(await client.retryKnowledge(params.knowledgeId)).data as Row], KNOWLEDGE_FIELDS)[0])
+        toolResult(pickFields([(await client.retryKnowledge(params.knowledgeId)).data], KNOWLEDGE_FIELDS)[0])
       )
   );
 

package/src/tools/maintenance.ts

@@ -20,8 +20,6 @@ import { page, pickFields } from './summarize.js';
  * next sweep no longer detects it, so there is no tool for either.
  */
 
-type Row = Record<string, unknown>;
-
 /** A finding as a list row: enough to decide whether to open, fix or ignore it. */
 const FINDING_ROW_FIELDS = [
   'id',
@@ -99,11 +97,11 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
           client.getMaintenanceSummary(params.productId),
           client.listMaintenanceSweeps(params.productId, { limit: 3 }),
         ]);
-        const latest = pickFields(sweeps.data as Row[], SWEEP_FIELDS);
+        const latest = pickFields(sweeps.data, SWEEP_FIELDS);
         // The sweeps are reported as `latestSweeps`, narrowed to SWEEP_FIELDS;
         // the summary's own run rows (PRO-2527: one per repository) would
         // repeat them with every column.
-        const { lastRun: _lastRun, lastRuns: _lastRuns, ...standing } = summary.data as Row;
+        const { lastRun: _lastRun, lastRuns: _lastRuns, ...standing } = summary.data;
         return toolResult({
           ...standing,
           latestSweeps: latest,
@@ -141,7 +139,7 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
         const { productId: id, ...filters } = params;
         const result = await client.listFindings(id, filters);
         return toolResult({
-          ...page(pickFields(result.data as Row[], FINDING_ROW_FIELDS), result.nextCursor),
+          ...page(pickFields(result.data, FINDING_ROW_FIELDS), result.nextCursor),
           ...(typeof result.totalCount === 'number' ? { totalCount: result.totalCount } : {}),
         });
       })
@@ -186,9 +184,9 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
     },
     (params) =>
       runTool(async () => {
-        const standing = (await client.getPolicyStanding(params.productId)).data as Row;
-        const controls = Array.isArray(standing.controls) ? (standing.controls as Row[]) : [];
-        const violations = Array.isArray(standing.divergences) ? (standing.divergences as Row[]) : [];
+        const standing = (await client.getPolicyStanding(params.productId)).data;
+        const controls = Array.isArray(standing.controls) ? standing.controls : [];
+        const violations = Array.isArray(standing.divergences) ? standing.divergences : [];
         const resolved = Array.isArray(standing.resolvedDivergences) ? standing.resolvedDivergences.length : 0;
         const listed = controls.filter((c) => Number(c.divergenceCount ?? 0) > 0 || Number(c.findingCount ?? 0) > 0);
         const bySeverity: Record<string, number> = {};
@@ -268,7 +266,7 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
               ...(params.expiresAt !== undefined ? { ignoreExpiresAt: params.expiresAt } : {}),
             }
           : { status: 'open' as const };
-        const finding = (await client.updateFinding(params.findingId, body)).data as Row;
+        const finding = (await client.updateFinding(params.findingId, body)).data;
         return toolResult(pickFields([finding], [...FINDING_ROW_FIELDS, 'ignoreNote'])[0]);
       })
   );
@@ -299,10 +297,7 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
     (params) =>
       runTool(async () => {
         if (!params.wholeGroup) {
-          const fixed = (await client.remediateFinding(params.productId, params.findingId)).data as {
-            finding?: Row;
-            backlogItemId?: unknown;
-          };
+          const fixed = (await client.remediateFinding(params.productId, params.findingId)).data;
           return toolResult({
             backlogItemId: fixed.backlogItemId,
             finding: fixed.finding ? pickFields([fixed.finding], FINDING_ROW_FIELDS)[0] : null,
@@ -311,7 +306,7 @@ export function registerMaintenanceTools(server: McpServer, client: TaigaClient)
         // The group is the finding's own: the route matches the package (or
         // rule), the installed version and the repository exactly, so they are
         // taken from the finding rather than asked of the caller.
-        const finding = (await client.getFinding(params.findingId)).data as Row;
+        const finding = (await client.getFinding(params.findingId)).data;
         // The finding is read by its own id, so it is held to the product the
         // group fix is sent to, as the single-finding route holds it.
         if (finding.productId !== params.productId) {

package/src/tools/markdown.ts

@@ -1,7 +1,13 @@
 import { fromMarkdown } from 'mdast-util-from-markdown';
 import { toMarkdown } from 'mdast-util-to-markdown';
 import type { Heading, Node, Parent, PhrasingContent } from 'mdast';
-import { isRecord, sectionContent, sectionsOf } from './sections.js';
+import { isRecord, isSectionObject, sectionContent, sectionsOf, type StoredDocument } from './sections.js';
+
+/** A document as rendered: its data, and the facts its title and header line name. */
+interface RenderedDocument extends StoredDocument {
+  name?: unknown;
+  type?: unknown;
+}
 
 /**
  * A document as text an IDE can attach: the name as the title, one line of
@@ -11,7 +17,7 @@ import { isRecord, sectionContent, sectionsOf } from './sections.js';
  * described, and a document that is no section map at all is handed over as
  * JSON.
  */
-export function renderDocument(doc: Record<string, unknown>): { mimeType: string; text: string } {
+export function renderDocument(doc: RenderedDocument): { mimeType: string; text: string } {
   const data = isRecord(doc.data) ? doc.data : null;
   const sections = data ? sectionsOf(data) : null;
   if (!data || !sections) return { mimeType: 'application/json', text: JSON.stringify(doc, null, 2) };
@@ -25,7 +31,7 @@ export function renderDocument(doc: Record<string, unknown>): { mimeType: string
   // the headings: a heading is text a section could forge, this line is not.
   const core = Object.keys(sections).filter((id) => {
     const section = sections[id];
-    return isRecord(section) && section.priority === 'core';
+    return isSectionObject(section) && section.priority === 'core';
   });
   if (core.length > 0) facts.push(`core sections: ${core.join(', ')}`);
   if (facts.length > 0) lines.push('', facts.join(' | '));
@@ -120,11 +126,13 @@ function atxOf(depth: Heading['depth'], children: PhrasingContent[]): string {
 
 /** The section's title when it carries one, else its id. */
 function sectionTitle(section: unknown, id: string): string {
-  return isRecord(section) && typeof section.title === 'string' && section.title.trim() ? section.title.trim() : id;
+  return isSectionObject(section) && typeof section.title === 'string' && section.title.trim()
+    ? section.title.trim()
+    : id;
 }
 
 /** The mime type a read will answer with, for a list entry that must not disagree with it. */
-export function mimeTypeOf(doc: Record<string, unknown>): string {
+export function mimeTypeOf(doc: StoredDocument): string {
   const data = isRecord(doc.data) ? doc.data : null;
   return data && sectionsOf(data) ? 'text/markdown' : 'application/json';
 }

package/src/tools/observe.ts

@@ -1,7 +1,8 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { ENVIRONMENT_TYPES } from '@taiga/types';
 import { z } from 'zod';
-import { TaigaApiError, type TaigaClient } from '../client.js';
+import type { Deployment, Environment } from '@taiga/types';
+import { TaigaApiError, type TaigaClient, type WithoutTenant } from '../client.js';
 import { OPERATE, OPERATE_SETTING, READ_ONLY } from './annotations.js';
 import { isNetworkFailure, runTool, toolError, toolResult } from './errors.js';
 import { withNotFoundHint } from './hints.js';
@@ -16,8 +17,6 @@ import { page, pickFields } from './summarize.js';
  * provider and is an administrator's action in the web.
  */
 
-type Row = Record<string, unknown>;
-
 /** A deployment as a line of history: what shipped where, how it ended, and who shipped it. */
 const DEPLOYMENT_FIELDS = [
   'id',
@@ -44,9 +43,10 @@ const ENVIRONMENT_FIELDS = ['id', 'name', 'slug', 'type', 'ordinal', 'status', '
  * repository runs its own deployment in an environment, so two running in
  * production are two repositories, not a contradiction (PRO-2528).
  */
-function deploymentLines(rows: Row[]): Row[] {
+function deploymentLines(rows: WithoutTenant<Deployment>[]) {
   return rows.map((row) => {
-    const repository = (row.metadata as Row | undefined)?.repositoryFullName;
+    // `metadata` is an untyped jsonb column until PRO-2515 types it.
+    const repository = row.metadata?.['repositoryFullName'];
     return {
       ...pickFields([row], DEPLOYMENT_FIELDS)[0],
       repository: typeof repository === 'string' ? repository : null,
@@ -77,12 +77,15 @@ async function part<T>(read: () => Promise<T>): Promise<{ value: T } | { unavail
 const ENVIRONMENT_PAGES = 5;
 
 /** Every environment of a product, page by page, and whether any were left past the guard. */
-async function allEnvironments(client: TaigaClient, product: string): Promise<{ rows: Row[]; more: boolean }> {
-  const rows: Row[] = [];
+async function allEnvironments(
+  client: TaigaClient,
+  product: string
+): Promise<{ rows: WithoutTenant<Environment>[]; more: boolean }> {
+  const rows: WithoutTenant<Environment>[] = [];
   let cursor: string | undefined;
   for (let pageNo = 0; pageNo < ENVIRONMENT_PAGES; pageNo++) {
     const result = await client.listEnvironments(product, { limit: 100, cursor });
-    rows.push(...(result.data as Row[]));
+    rows.push(...result.data);
     if (!result.nextCursor) return { rows, more: false };
     cursor = result.nextCursor;
   }
@@ -119,14 +122,14 @@ export function registerObserveTools(server: McpServer, client: TaigaClient) {
           }),
           part(() => client.getDeploymentSyncStatus(params.productId)),
         ]);
-        const now = current.data as { current?: Row[]; deploying?: Row[] };
+        const now = current.data;
         // An empty answer says why, as the maintenance read does: no
         // environment, or none deployed to yet, is not "nothing is wrong".
         const note =
           environments.rows.length === 0
             ? 'This product has no environments yet: an environment is defined with taiga_define_environment, ' +
               'and its deployments are mirrored from the provider once it is.'
-            : (history.data as Row[]).length === 0 && !params.cursor
+            : history.data.length === 0 && !params.cursor
               ? 'No deployments recorded yet: none was mirrored from the provider (syncStatus says when it last ' +
                 'synced), or nothing has been deployed.'
               : null;
@@ -135,7 +138,7 @@ export function registerObserveTools(server: McpServer, client: TaigaClient) {
           ...(environments.more ? { moreEnvironments: true } : {}),
           running: deploymentLines(now.current ?? []),
           deploying: deploymentLines(now.deploying ?? []),
-          history: page(deploymentLines(history.data as Row[]), history.nextCursor),
+          history: page(deploymentLines(history.data), history.nextCursor),
           ...('value' in sync
             ? { syncStatus: sync.value.data }
             : { syncStatus: null, syncUnavailable: sync.unavailable }),
@@ -241,7 +244,7 @@ export function registerObserveTools(server: McpServer, client: TaigaClient) {
         }
         const value = (p: { value: { data: unknown } } | { unavailable: string }) =>
           'value' in p ? p.value.data : { unavailable: p.unavailable };
-        const envHealth = (health.data as Row[]).filter((row) => row.environmentId === env);
+        const envHealth = health.data.filter((row) => row.environmentId === env);
         return toolResult({
           health: envHealth,
           ...(envHealth.length === 0
@@ -282,7 +285,7 @@ export function registerObserveTools(server: McpServer, client: TaigaClient) {
     (params) =>
       runTool(async () => {
         const created = (await client.createEnvironment(params.productId, { name: params.name, type: params.type }))
-          .data as Row;
+          .data;
         return toolResult(pickFields([created], ENVIRONMENT_FIELDS)[0]);
       })
   );
@@ -310,7 +313,7 @@ export function registerObserveTools(server: McpServer, client: TaigaClient) {
         if (Object.values(changes).every((value) => value === undefined)) {
           return toolError('VALIDATION_ERROR', 'Change at least one of name, type or url.');
         }
-        const updated = (await client.updateEnvironment(id, changes)).data as Row;
+        const updated = (await client.updateEnvironment(id, changes)).data;
         return toolResult(pickFields([updated], ENVIRONMENT_FIELDS)[0]);
       })
   );

package/src/tools/product-documents.ts

@@ -8,7 +8,7 @@ import {
   SETUP_REQUIRED_DOCUMENT_TYPES,
 } from '@taiga/types';
 import { z } from 'zod';
-import type { TaigaClient, TaigaDocument } from '../client.js';
+import type { TaigaClient } from '../client.js';
 import { OPERATE, WRITE } from './annotations.js';
 import { type DocumentScope, publishDraft, sectionContentInput, sectionIdFrom, updateSection } from './documents.js';
 import { runTool, toolError, toolResult } from './errors.js';
@@ -25,8 +25,6 @@ import { jobReport } from './jobs.js';
  * code and is not edited.
  */
 
-type Row = Record<string, unknown>;
-
 /** The plan-side documents people edit; the codebase snapshot is derived from the code, never written. */
 type EditableType = Exclude<ProductDocumentType, 'codebase_snapshot'>;
 const EDITABLE_TYPES = PRODUCT_DOCUMENT_TYPES.filter((type): type is EditableType => type !== 'codebase_snapshot') as [
@@ -56,7 +54,7 @@ export function registerProductDocumentWrites(server: McpServer, client: TaigaCl
 
   const productScope = (product: string, type: string): DocumentScope => ({
     getDraft: () => client.getProductDocumentDraft(product, type),
-    getPublished: async () => (await client.getProductDocument(product, type, 'plan')) as { data: TaigaDocument },
+    getPublished: () => client.getProductDocument(product, type, 'plan'),
     saveDraft: (data) => client.saveProductDocumentDraft(product, type, { data }),
     publish: () => client.publishProductDocument(product, type),
   });
@@ -155,7 +153,7 @@ export function registerProductDocumentWrites(server: McpServer, client: TaigaCl
               targetId: params.productId,
               documentType: params.type,
             })
-          ).data as Row;
+          ).data;
           return toolResult(jobReport(job));
         })
     );

package/src/tools/products.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
-import { TaigaApiError, type TaigaClient } from '../client.js';
+import type { Product, ProductDocumentListItem } from '@taiga/types';
+import { TaigaApiError, type TaigaClient, type WithoutTenant } from '../client.js';
 import { READ_ONLY } from './annotations.js';
 import { idInput, pagination, productId, remoteUrl, slug } from './inputs.js';
 import {
@@ -22,6 +23,9 @@ import { parseRemote } from './remote.js';
 import { sectionReadResult, sectionsInput, stripProvenance } from './sections.js';
 import { SEARCH_NOTE, SEARCH_PAGE_SIZE, SEARCH_WITH_CURSOR, page, pickFields, searchPages } from './summarize.js';
 
+type ProductRow = WithoutTenant<Product>;
+type DocumentRow = WithoutTenant<ProductDocumentListItem>;
+
 /** What a product row needs to say for the model to pick one and read it in full. */
 // Not `kind`: it is parked behind a flag that is on nowhere, so every row said null.
 export const PRODUCT_SUMMARY_FIELDS = ['id', 'name', 'slug', 'status', 'factoryId', 'discoveryStep'] as const;
@@ -72,11 +76,11 @@ const originInput = z
  * than being folded into a truncated list that would read as a complete one.
  */
 async function linkedProducts(client: TaigaClient, repository: string, repositoryHost: string) {
-  const products: Record<string, unknown>[] = [];
+  const products: ProductRow[] = [];
   let cursor: string | undefined;
   for (let page = 0; page < RESOLVE_PAGE_LIMIT; page += 1) {
     const result = await client.listProducts({ repository, repositoryHost, limit: PAGE_SIZE, cursor });
-    products.push(...(result.data as Record<string, unknown>[]));
+    products.push(...result.data);
     if (!result.nextCursor) return { products, truncated: false };
     cursor = result.nextCursor;
   }
@@ -84,15 +88,14 @@ async function linkedProducts(client: TaigaClient, repository: string, repositor
 }
 
 /** A document list row as the model sees it: the summary fields plus a display name and the staleness fact. */
-function documentSummaries(rows: unknown[]): Record<string, unknown>[] {
-  const typed = rows as Record<string, unknown>[];
-  return pickFields(typed, DOCUMENT_SUMMARY_FIELDS).map((picked, index) => {
+function documentSummaries(rows: DocumentRow[]) {
+  return pickFields(rows, DOCUMENT_SUMMARY_FIELDS).map((picked, index) => {
     // `outdated` on the wire is the list of sources that moved on; the model
     // needs the fact, not the tree. Published plan rows carry it: null when
     // current, a source list when not. A draft has nothing published to be
     // outdated (the API stamps it null too) and reality rows carry no such
     // field: no fact for either.
-    const outdated = typed[index]!.outdated as { sources?: unknown[] } | null | undefined;
+    const outdated = rows[index]!.outdated;
     const fact =
       picked.isDraft !== false
         ? undefined
@@ -110,12 +113,14 @@ function documentSummaries(rows: unknown[]): Record<string, unknown>[] {
   });
 }
 
+type DocumentSummary = ReturnType<typeof documentSummaries>[number];
+
 interface Timelines {
   projectType: 'greenfield' | 'brownfield';
   defaultOrigin: ProductDocumentOrigin;
   /** The side's summaries, or null when the API could not list it (see `unlistable`). */
-  plan: Record<string, unknown>[] | null;
-  reality: Record<string, unknown>[] | null;
+  plan: DocumentSummary[] | null;
+  reality: DocumentSummary[] | null;
   /** Why a null side is null, in the words the notes and a miss message use. */
   unlistable: Partial<Record<ProductDocumentOrigin, string>>;
   notes: string[];
@@ -134,7 +139,7 @@ function unlistableNote(origin: ProductDocumentOrigin, reason: unknown): string
  * so a caller that already holds it passes it in.
  */
 async function documentTimelines(client: TaigaClient, id: string, product?: ProductSettingsView): Promise<Timelines> {
-  const loaded = product ?? ((await client.getProduct(id)).data as ProductSettingsView);
+  const loaded = product ?? (await client.getProduct(id)).data;
   // Each side on its own: one side the API cannot list is reported as
   // unreadable, not as empty, and never hides the side that did answer.
   // Both failing is the API failing, and that is an error like any other.
@@ -142,7 +147,7 @@ async function documentTimelines(client: TaigaClient, id: string, product?: Prod
     PRODUCT_DOCUMENT_ORIGINS.map((o) => client.listProductDocuments(id, { origin: o, limit: PAGE_SIZE }))
   );
   if (settled.every((result) => result.status === 'rejected')) throw settled[0]!.reason;
-  const sides: Partial<Record<ProductDocumentOrigin, Record<string, unknown>[] | null>> = {};
+  const sides: Partial<Record<ProductDocumentOrigin, DocumentSummary[] | null>> = {};
   const unlistable: Partial<Record<ProductDocumentOrigin, string>> = {};
   PRODUCT_DOCUMENT_ORIGINS.forEach((o, index) => {
     const result = settled[index]!;
@@ -167,10 +172,10 @@ async function documentTimelines(client: TaigaClient, id: string, product?: Prod
   };
 }
 
-const isPublished = (row: Record<string, unknown>) => row.isDraft === false;
+const isPublished = (row: { isDraft?: boolean }) => row.isDraft === false;
 
 /** `specification (v2), architecture (draft)` for one side. */
-function sideList(rows: Record<string, unknown>[]): string {
+function sideList(rows: DocumentSummary[]): string {
   return rows
     .map((row) => `${String(row.type)} (${isPublished(row) ? `v${String(row.version)}` : 'draft'})`)
     .join(', ');
@@ -218,7 +223,7 @@ export async function resolveProductRef(
   accepted: readonly string[],
   /** How the caller's arguments are passed, for the message when none was given (a slash command's usage). */
   usage?: string
-): Promise<{ product: Record<string, unknown> } | { refusal: { code: string; message: string } }> {
+): Promise<{ product: ProductRow } | { refusal: { code: string; message: string } }> {
   const refusal = (code: string, message: string) => ({ refusal: { code, message } });
   const given = [ref.productId, ref.slug, ref.remoteUrl].filter((v) => v !== undefined).length;
   if (given !== 1) {
@@ -228,7 +233,7 @@ export async function resolveProductRef(
   }
   if (ref.productId) {
     try {
-      return { product: (await client.getProduct(ref.productId)).data as Record<string, unknown> };
+      return { product: (await client.getProduct(ref.productId)).data };
     } catch (error) {
       if (!isMissOrRefusal(error)) throw error;
       return refusal(
@@ -238,7 +243,7 @@ export async function resolveProductRef(
     }
   }
   if (ref.slug) {
-    const [product] = (await client.listProducts({ slug: ref.slug, limit: 1 })).data as Record<string, unknown>[];
+    const [product] = (await client.listProducts({ slug: ref.slug, limit: 1 })).data;
     if (!product) {
       return refusal(
         'NOT_FOUND',
@@ -341,9 +346,7 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
           const { query: text, ...filters } = params;
           if (text === undefined) {
             const result = await client.listProducts(filters);
-            return toolResult(
-              page(pickFields(result.data as Record<string, unknown>[], PRODUCT_SUMMARY_FIELDS), result.nextCursor)
-            );
+            return toolResult(page(pickFields(result.data, PRODUCT_SUMMARY_FIELDS), result.nextCursor));
           }
           if (params.cursor !== undefined) return toolError('VALIDATION_ERROR', SEARCH_WITH_CURSOR);
           const found = await searchPages(
@@ -483,11 +486,11 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
           // The product's own timeline when none is asked for; the API's
           // default is plan, which is the wrong side of an imported product.
           let product: ProductSettingsView | undefined;
-          if (!params.origin) product = (await client.getProduct(params.productId)).data as ProductSettingsView;
+          if (!params.origin) product = (await client.getProduct(params.productId)).data;
           const origin = params.origin ?? defaultOriginFor(product, params.type);
           try {
             const result = await client.getProductDocument(params.productId, params.type, origin);
-            const doc = stripProvenance(result.data as Record<string, unknown>);
+            const doc = stripProvenance(result.data);
             if (!params.sections) return toolResult(doc);
             return sectionReadResult(doc, params.sections, `${origin} ${params.type}`);
           } catch (error) {
@@ -496,7 +499,7 @@ export function registerProductTools(server: McpServer, client: TaigaClient) {
             // miss, so the product read propagates. The lists after it are
             // best effort per side (documentTimelines); only both failing
             // propagates, as the API failing.
-            product ??= (await client.getProduct(params.productId)).data as ProductSettingsView;
+            product ??= (await client.getProduct(params.productId)).data;
             const timelines = await documentTimelines(client, params.productId, product);
             return toolError('NOT_FOUND', describeMiss(params.type, origin, timelines, product));
           }

package/src/tools/prompts.ts

@@ -1,7 +1,7 @@
 import { type GetPromptResult, type McpServer, ProtocolError, ProtocolErrorCode } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { TaigaApiError, type TaigaClient } from '../client.js';
-import { POLICY_TYPES, defaultOriginFor, type ProductSettingsView } from './catalogue.js';
+import { POLICY_TYPES, defaultOriginFor } from './catalogue.js';
 import { productContext } from './context.js';
 import { apiFailureCode, apiFailureText, isMissOrRefusal, isNetworkFailure, networkFailureDetail } from './errors.js';
 import { idInput, productId, remoteUrl, slug } from './inputs.js';
@@ -126,12 +126,12 @@ export function registerPrompts(server: McpServer, client: TaigaClient) {
             client.getBacklogItem(args.itemId),
             'No backlog item with that ID the key can see; taiga_list_backlog_items shows what exists'
           )
-        ).data as Record<string, unknown>;
+        ).data;
         const productId = String(item.productId);
         const product = (
           await served(client.getProduct(productId), 'The product of that item is not visible to the key')
-        ).data as Record<string, unknown>;
-        const origin = defaultOriginFor(product as ProductSettingsView, 'architecture');
+        ).data;
+        const origin = defaultOriginFor(product, 'architecture');
 
         // The three reads are independent; each answers for itself.
         const [architecture, instructions, policies] = await Promise.allSettled([
@@ -146,10 +146,7 @@ export function registerPrompts(server: McpServer, client: TaigaClient) {
 
         const architectureText =
           architecture.status === 'fulfilled'
-            ? fenced(
-                'markdown',
-                renderDocument(stripProvenance(architecture.value.data as Record<string, unknown>)).text
-              )
+            ? fenced('markdown', renderDocument(stripProvenance(architecture.value.data)).text)
             : isNotFound(architecture.reason)
               ? `(No published ${origin} architecture; taiga_list_product_documents shows what exists.)`
               : unreadable('The architecture', architecture.reason);
@@ -170,14 +167,11 @@ export function registerPrompts(server: McpServer, client: TaigaClient) {
           policies.status === 'fulfilled'
             ? fenced(
                 'text',
-                (policies.value.data as Record<string, unknown>[])
+                policies.value.data
                   .filter(
                     (row) => (POLICY_TYPES as readonly string[]).includes(String(row.type)) && row.isDraft === false
                   )
-                  .map(
-                    (row) =>
-                      `- ${String(row.type)}: ${Object.keys(sectionsOf((row.data as Record<string, unknown>) ?? {}) ?? {}).join(', ')}`
-                  )
+                  .map((row) => `- ${String(row.type)}: ${Object.keys(sectionsOf(row.data ?? {}) ?? {}).join(', ')}`)
                   .join('\n') || '(No policy is published.)'
               )
             : policies.reason instanceof NotGranted

package/src/tools/queue.ts

@@ -1,5 +1,14 @@
 import type { McpServer } from '@modelcontextprotocol/server';
-import { HALT_CAUSES, canResumeHalt, haltClearsItself, renderHalt, type Halt, type HaltCause } from '@taiga/types';
+import {
+  HALT_CAUSES,
+  canResumeHalt,
+  haltClearsItself,
+  renderHalt,
+  type BacklogItem,
+  type BacklogItemLifecycle,
+  type Halt,
+  type HaltCause,
+} from '@taiga/types';
 import { TaigaApiError, type TaigaClient } from '../client.js';
 import { z } from 'zod';
 import { OPERATE_SETTING, READ_ONLY } from './annotations.js';
@@ -10,7 +19,21 @@ import { criteriaCounts } from './summarize.js';
 /** How many entries the read names; past this an entry keeps its backlogItemId only. */
 const NAMED_ENTRIES = 25;
 
-type Row = Record<string, unknown>;
+/** One queue entry as the read reports it: where it sits, and its initiative when that could be named. */
+interface QueueRow {
+  position: number;
+  backlogItemId: string;
+  entryState: string;
+  title?: string;
+  state?: BacklogItem['state'];
+  planningStatus?: BacklogItem['planningStatus'];
+  needsHumanCause?: BacklogItem['needsHumanCause'];
+  criteria?: { met: number; total: number } | null;
+  lifecycle?: Pick<BacklogItemLifecycle, 'turn' | 'stage' | 'cta'> | null;
+  buildId?: string;
+  prUrl?: string | null;
+  halt?: { cause: string | null; reason: string; nextStep: string };
+}
 
 const MOVE_ASIDE =
   'or move it down (taiga_queue_backlog_item with afterId) or off the line (taiga_move_backlog_item) to let the rest pass.';
@@ -45,7 +68,7 @@ function blockingIndex<T>(entries: T[], stateOf: (entry: T) => unknown): number
 }
 
 /** The one sentence a person needs: what the line is doing, or what it is waiting on. */
-function waitingOn(rows: Row[]): string | null {
+function waitingOn(rows: QueueRow[]): string | null {
   const at = blockingIndex(rows, (row) => row.entryState);
   if (at < 0) {
     return rows.length > 0
@@ -59,7 +82,7 @@ function waitingOn(rows: Row[]): string | null {
     const ahead = at > 0 ? ' Entries ahead of it are not held by it.' : '';
     return `${name} halted the queue, holding the entries behind it: ${halt.reason} ${halt.nextStep}${ahead}`;
   }
-  const lifecycle = head.lifecycle as { turn?: unknown; stage?: unknown; cta?: unknown } | undefined;
+  const lifecycle = head.lifecycle;
   const held = 'every other queued initiative waits until its pull request merges.';
   if (!lifecycle) return `${name} is the active entry; ${held}`;
   const pr = typeof head.prUrl === 'string' ? ` (${head.prUrl})` : '';
@@ -86,7 +109,7 @@ export async function queueView(
   options: { name: 'all' | 'blocking' } = { name: 'all' }
 ) {
   const [queue, paused] = await Promise.all([client.listQueue(product), linePausedSince(client, product)]);
-  const entries = (queue.data as Row[]).filter((entry) => entry.state !== 'settled');
+  const entries = queue.data.filter((entry) => entry.state !== 'settled');
   const canName = client.hasCapability('backlog:read');
   // 'blocking' names only the entry the line waits on: a caller after one
   // position and waitingOn need no more reads than that.
@@ -98,9 +121,7 @@ export async function queueView(
       : blocking >= 0
         ? [blocking]
         : [];
-  const settled = await Promise.allSettled(
-    toName.map((index) => client.getBacklogItem(String(entries[index]!.backlogItemId)))
-  );
+  const settled = await Promise.allSettled(toName.map((index) => client.getBacklogItem(entries[index]!.backlogItemId)));
   const reads = new Map(toName.map((index, at) => [index, settled[at]!]));
   let unnamed = options.name === 'all' ? entries.length - toName.length : 0;
   const rows = entries.map((entry, index) => {
@@ -110,10 +131,10 @@ export async function queueView(
       if (!(read.reason instanceof TaigaApiError || isNetworkFailure(read.reason))) throw read.reason;
       unnamed += 1;
     }
-    const item = read?.status === 'fulfilled' ? (read.value.data as Row) : null;
-    const lifecycle = item?.lifecycle as Row | undefined;
-    const latestBuild = lifecycle?.latestBuild as Row | null | undefined;
-    const row: Row = { position: index + 1, backlogItemId: entry.backlogItemId, entryState: entry.state };
+    const item = read?.status === 'fulfilled' ? read.value.data : null;
+    const lifecycle = item?.lifecycle;
+    const latestBuild = lifecycle?.latestBuild;
+    const row: QueueRow = { position: index + 1, backlogItemId: entry.backlogItemId, entryState: entry.state };
     if (item) {
       Object.assign(row, {
         title: item.title,
@@ -123,7 +144,7 @@ export async function queueView(
         criteria: criteriaCounts(item),
         lifecycle: lifecycle ? { turn: lifecycle.turn, stage: lifecycle.stage, cta: lifecycle.cta } : null,
         ...(latestBuild ? { buildId: latestBuild.id, prUrl: latestBuild.prUrl ?? null } : {}),
-      });
+      } satisfies Partial<QueueRow>);
     }
     if (entry.state === 'halted') {
       const cause = typeof entry.haltCause === 'string' ? entry.haltCause : null;
@@ -165,7 +186,7 @@ export async function queueView(
  */
 async function linePausedSince(client: TaigaClient, product: string): Promise<string | false | null> {
   try {
-    const row = (await client.getProduct(product)).data as { lineStoppedAt?: unknown };
+    const row = (await client.getProduct(product)).data;
     return typeof row.lineStoppedAt === 'string' ? row.lineStoppedAt : false;
   } catch (error) {
     if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
@@ -214,7 +235,7 @@ export function registerQueueTools(server: McpServer, client: TaigaClient) {
     },
     (params) =>
       runTool(async () => {
-        const row = (await client.setLineStopped(params.productId, params.paused)).data as Row;
+        const row = (await client.setLineStopped(params.productId, params.paused)).data;
         return toolResult({
           productId: row.id,
           linePaused: typeof row.lineStoppedAt === 'string',