@taiga-ai/mcp-server 0.18.0-rc.445 → 0.19.0-dev.451

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';
@@ -97,7 +97,7 @@ export function registerPrompts(server: McpServer, client: TaigaClient) {
             '',
             'Before writing code: follow the factory instructions; read the policy sections that touch what you are',
             'about to change with taiga_get_document (security, data, SDLC, architecture at least); read the backlog',
-            'item you are implementing with taiga_get_backlog_item. Parts listed under notGranted or unavailable',
+            'item you are implementing with taiga_get_initiative. Parts listed under notGranted or unavailable',
             'could not be read; say so rather than assuming they are empty.',
             '',
             fenced('json', bundle),
@@ -109,29 +109,29 @@ export function registerPrompts(server: McpServer, client: TaigaClient) {
 
   if (client.hasCapability('backlog:read') && client.hasCapability('products:read')) {
     server.registerPrompt(
-      'taiga_implement_backlog_item',
+      'taiga_implement_initiative',
       {
-        title: 'Implement a backlog item',
+        title: 'Implement an initiative',
         description:
           'Implement one initiative: its description and acceptance criteria, the architecture of the product ' +
           "from its own timeline, the factory's instructions and the policy sections to check against. " +
-          'taiga_list_backlog_items gives the item ID.',
+          'taiga_list_initiatives gives the item ID.',
         argsSchema: z.object({
-          itemId: idInput('backlog item', 'taiga_list_backlog_items (query finds one by title) gives it'),
+          initiativeId: idInput('initiative', 'taiga_list_initiatives (query finds one by title) gives it'),
         }),
       },
       async (args) => {
         const item = (
           await served(
-            client.getBacklogItem(args.itemId),
-            'No backlog item with that ID the key can see; taiga_list_backlog_items shows what exists'
+            client.getBacklogItem(args.initiativeId),
+            'No initiative with that ID the key can see; taiga_list_initiatives 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';
@@ -7,13 +16,27 @@ import { isNetworkFailure, runTool, toolResult } from './errors.js';
 import { productId } from './inputs.js';
 import { criteriaCounts } from './summarize.js';
 
-/** How many entries the read names; past this an entry keeps its backlogItemId only. */
+/** How many entries the read names; past this an entry keeps its initiativeId 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;
+  runId?: 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.';
+  'or move it down (taiga_queue_initiative with afterId) or off the line (taiga_move_initiative) to let the rest pass.';
 
 /**
  * What lifts a halt, in the tools that do it. Read from the halt registry in
@@ -26,11 +49,11 @@ function haltNextStep(cause: string | null): string {
     return 'Read the plan with taiga_get_plan, then approve it (taiga_approve_plan) or send it back (taiga_reject_plan).';
   }
   const spec = cause ? (HALT_CAUSES as Record<string, { clearedWhen: string } | undefined>)[cause] : undefined;
-  if (!cause || !spec) return `Read the initiative with taiga_get_backlog_item to see why, ${MOVE_ASIDE}`;
+  if (!cause || !spec) return `Read the initiative with taiga_get_initiative to see why, ${MOVE_ASIDE}`;
   const known = cause as HaltCause;
-  if (canResumeHalt(known)) return `taiga_resume_backlog_item lifts it, ${MOVE_ASIDE}`;
+  if (canResumeHalt(known)) return `taiga_resume_initiative lifts it, ${MOVE_ASIDE}`;
   if (haltClearsItself(known)) return `It clears when ${spec.clearedWhen}; ${MOVE_ASIDE}`;
-  return `Only taking it off the line clears it (taiga_move_backlog_item): ${spec.clearedWhen}.`;
+  return `Only taking it off the line clears it (taiga_move_initiative): ${spec.clearedWhen}.`;
 }
 
 /**
@@ -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,
@@ -122,8 +143,8 @@ export async function queueView(
         needsHumanCause: item.needsHumanCause,
         criteria: criteriaCounts(item),
         lifecycle: lifecycle ? { turn: lifecycle.turn, stage: lifecycle.stage, cta: lifecycle.cta } : null,
-        ...(latestBuild ? { buildId: latestBuild.id, prUrl: latestBuild.prUrl ?? null } : {}),
-      });
+        ...(latestBuild ? { runId: latestBuild.id, prUrl: latestBuild.prUrl ?? null } : {}),
+      } satisfies Partial<QueueRow>);
     }
     if (entry.state === 'halted') {
       const cause = typeof entry.haltCause === 'string' ? entry.haltCause : null;
@@ -142,10 +163,10 @@ export async function queueView(
     unnamed === 0
       ? null
       : !canName
-        ? 'Entries carry backlogItemId only: naming them needs backlog:read, which this key lacks.'
+        ? 'Entries carry initiativeId only: naming them needs backlog:read, which this key lacks.'
         : entries.length > NAMED_ENTRIES
-          ? `Only the first ${NAMED_ENTRIES} entries are named; the rest carry backlogItemId only.`
-          : 'An entry whose initiative could not be read carries backlogItemId only; taiga_get_backlog_item reads it.';
+          ? `Only the first ${NAMED_ENTRIES} entries are named; the rest carry initiativeId only.`
+          : 'An entry whose initiative could not be read carries initiativeId only; taiga_get_initiative reads it.';
   // A paused line answers before anything in it: nothing is planned or built until it is resumed.
   const line =
     typeof paused === 'string'
@@ -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;
@@ -177,7 +198,7 @@ export function registerQueueTools(server: McpServer, client: TaigaClient) {
   if (!client.hasCapability('products:read')) return;
 
   server.registerTool(
-    'taiga_get_queue',
+    'taiga_get_line',
     {
       title: 'Get the product queue',
       description:
@@ -205,7 +226,7 @@ export function registerQueueTools(server: McpServer, client: TaigaClient) {
         'keep their places. Resuming plans the interrupted initiative again from scratch, carries the interrupted ' +
         'build on from its first incomplete step, and the line picks up where it was; a build you had stopped ' +
         'yourself before pausing stays stopped. Idempotent. Pausing interrupts work and resuming starts it: read ' +
-        'taiga_get_queue first to see what it would interrupt, and ask the person.',
+        'taiga_get_line first to see what it would interrupt, and ask the person.',
       inputSchema: z.object({
         productId,
         paused: z.boolean().describe('true pauses the line, false resumes it'),
@@ -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',

package/src/tools/readiness.ts

@@ -0,0 +1,172 @@
+import { TaigaApiError, type TaigaClient } from '../client.js';
+import { PRODUCT_DOCUMENT_NAMES, isImportedProduct, setupNextStep, type ProductSettingsView } from './catalogue.js';
+import { isNetworkFailure } from './errors.js';
+
+type Row = Record<string, unknown>;
+
+/**
+ * What a product in setup still needs, read rather than learned from a
+ * refused write (PRO-2800). A reviewing agent linked a repository and picked
+ * a branch, and every read still said "link its repository": nextStep read
+ * the Discovery step alone, and the only way to see the missing documents was
+ * to call taiga_finish_discovery and read its refusal. This reads the same
+ * preconditions the API refuses on (GET /products/:id/setup), the linked
+ * repositories and the import, and says the one next move.
+ */
+export interface Readiness {
+  /** Whether taiga_finish_discovery would succeed now. Null when the API could not say. */
+  ready: boolean | null;
+  /** Null when the links could not be read: not the same as none linked. */
+  repository: { linked: false } | { linked: true; name: unknown; branch: unknown } | null;
+  /** An imported product's import: not started, running, complete, failed. */
+  import?: string;
+  discoveryStep?: unknown;
+  /** The required documents not yet published, by name; null when the API could not say. */
+  missingDocuments: string[] | null;
+  /** The required checks not yet stamped (stamped in the web); null when the API could not say. */
+  openChecks: string[] | null;
+  /** The one move that gets it closer; null when too little could be read to say. */
+  nextStep: string | null;
+}
+
+const IMPORT_STATE: Record<string, string> = {
+  pending: 'not started',
+  analyzing: 'running',
+  generating_docs: 'running',
+  complete: 'complete',
+  failed: 'failed',
+  cancelled: 'failed',
+};
+
+/** A failure that is the API's (refused, missing, unreachable), not a bug in this code. */
+function isApiSide(error: unknown): boolean {
+  return error instanceof TaigaApiError || isNetworkFailure(error);
+}
+
+/** The documents by the names the web uses. */
+function named(types: string[]): string {
+  return types.map((type) => PRODUCT_DOCUMENT_NAMES[type as keyof typeof PRODUCT_DOCUMENT_NAMES] ?? type).join(', ');
+}
+
+/** The product's setup readiness, or null once it has finished setup. */
+export async function setupReadiness(client: TaigaClient, product: Row): Promise<Readiness | null> {
+  if (product['status'] !== 'draft') return null;
+  const id = String(product['id']);
+  const imported = isImportedProduct(product as ProductSettingsView);
+  const [repos, blockers, full] = await Promise.all([
+    client.listProductRepositories(id).then(
+      (result) => result.data as Row[],
+      (error: unknown) => {
+        if (isApiSide(error)) return null;
+        throw error;
+      }
+    ),
+    // An API from before the read answers 404 to it: fall back to the step.
+    client.getProductSetupBlockers(id).then(
+      (result) => result.data,
+      (error: unknown) => {
+        if (isApiSide(error)) return null;
+        throw error;
+      }
+    ),
+    // A write's answer carries no discoveryStep; the read derives it.
+    'discoveryStep' in product || imported
+      ? Promise.resolve(product)
+      : client.getProduct(id).then(
+          (result) => result.data as Row,
+          (error: unknown) => {
+            if (isApiSide(error)) return product;
+            throw error;
+          }
+        ),
+  ]);
+
+  const link = repos?.[0];
+  const repository = !repos
+    ? null
+    : link
+      ? { linked: true as const, name: link['repositoryName'], branch: link['effectiveBranch'] }
+      : { linked: false as const };
+  const settings = (product['settings'] ?? {}) as { importStatus?: unknown };
+  const importState = imported ? (IMPORT_STATE[String(settings.importStatus)] ?? 'not started') : undefined;
+  const missing = blockers ? blockers.missingDocuments : null;
+  const openChecks = blockers ? blockers.openChecks.map((check) => check.criterion) : null;
+  // What the API refuses on, nothing else: a running import is in nextStep, not a blocker.
+  const ready = blockers ? missing!.length === 0 && openChecks!.length === 0 : null;
+
+  return {
+    ready,
+    repository,
+    ...(importState ? { import: importState } : {}),
+    ...(imported ? {} : { discoveryStep: full['discoveryStep'] ?? null }),
+    missingDocuments: missing ? missing.map((type) => named([type])) : null,
+    openChecks,
+    nextStep: nextStepFor({
+      imported,
+      importState,
+      linked: repository?.linked ?? null,
+      missing,
+      openChecks,
+      product: full,
+    }),
+  };
+}
+
+function nextStepFor(state: {
+  imported: boolean;
+  importState: string | undefined;
+  /** Null when the links could not be read. */
+  linked: boolean | null;
+  missing: string[] | null;
+  openChecks: string[] | null;
+  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).';
+  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 as ProductSettingsView);
+    switch (state.importState) {
+      case 'running':
+        return 'The import is running and derives the documents from the code; taiga_wait_for_job follows it.';
+      case 'failed':
+        return 'The last import did not finish: taiga_start_import runs it again.';
+      case 'complete':
+        if (state.missing && state.missing.length > 0) {
+          return (
+            `The import finished but ${named(state.missing)} ${state.missing.length === 1 ? 'is' : 'are'} not ` +
+            'published: taiga_list_product_documents shows them, taiga_publish_product_document publishes a draft.'
+          );
+        }
+        return `The import is done: review the reality documents (taiga_list_product_documents), then ${finish}`;
+      default:
+        return 'taiga_start_import derives the documents from the code and runs by itself (paid agent work: ask first).';
+    }
+  }
+  // Without the API's read, the Discovery step is all there is to go on, and
+  // without that, nothing: a guess would send a product at its documents back
+  // to the conversation.
+  if (!state.missing) return setupNextStep(state.product as ProductSettingsView);
+  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}`;
+}

package/src/tools/repositories.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
-import type { TaigaClient } from '../client.js';
+import type { GithubRepository } from '@taiga/types';
+import type { TaigaClient, WithoutTenant } from '../client.js';
 import { OPERATE, OPERATE_SETTING, READ_ONLY } from './annotations.js';
 import { runTool, toolError, toolResult } from './errors.js';
 import { idInput, pagination, productId } from './inputs.js';
@@ -15,8 +16,6 @@ import { SEARCH_WITH_CURSOR, page, pickFields } from './summarize.js';
  * repositories it can reach to a product is a separate act, per product.
  */
 
-type Row = Record<string, unknown>;
-
 const LINK_FIELDS = [
   'id',
   'provider',
@@ -47,6 +46,8 @@ const GITHUB_REPOSITORY_FIELDS = [
   'defaultBranch',
   'description',
   'language',
+  // A product already links it (PRO-2800); absent from an API that predates the field.
+  'linked',
 ] as const;
 
 const repositoryId = idInput(
@@ -81,7 +82,7 @@ export function registerRepositoryTools(server: McpServer, client: TaigaClient)
           // The route answers one page of 100 and takes no cursor: past that, the list says it is cut.
           const result = await client.listProductRepositories(params.productId);
           return toolResult({
-            data: pickFields(result.data as Row[], LINK_FIELDS),
+            data: pickFields(result.data, LINK_FIELDS),
             truncated: result.nextCursor !== null,
           });
         })
@@ -115,7 +116,8 @@ export function registerRepositoryTools(server: McpServer, client: TaigaClient)
           "The repositories the organization's GitHub connection can reach, to link one to a product " +
           '(taiga_link_repository takes its id). Searches by name with query. Name the GitHub account (account: ' +
           'its login, the owner in owner/repo, or installationId) to read only its repositories; without one it ' +
-          'reads every connected account and takes rows from each in turn, so one account cannot fill the page. No ' +
+          'reads every connected account and takes rows from each in turn, so one account cannot fill the page. ' +
+          'linked: true means a product already links it (taiga_resolve_product says which). No ' +
           'connection means GitHub is not connected yet: that is done once, in the web, by someone who can ' +
           'install the app.',
         inputSchema: z.object({
@@ -135,7 +137,7 @@ export function registerRepositoryTools(server: McpServer, client: TaigaClient)
       },
       (params) =>
         runTool(async () => {
-          const installations = (await client.listGithubInstallations()).data as Row[];
+          const installations = (await client.listGithubInstallations()).data;
           const accounts = pickFields(installations, INSTALLATION_FIELDS);
           if (installations.length === 0) {
             return toolError(
@@ -167,7 +169,7 @@ export function registerRepositoryTools(server: McpServer, client: TaigaClient)
           // are read: a search answers its ranked matches whatever the page
           // size, and several accounts add up.
           const max = params.limit ?? 25;
-          const rows = (data: unknown[]) => pickFields(data as Row[], GITHUB_REPOSITORY_FIELDS);
+          const rows = (data: WithoutTenant<GithubRepository>[]) => pickFields(data, GITHUB_REPOSITORY_FIELDS);
           if (chosen.length === 1) {
             const result = await client.listInstallationRepositories(String(chosen[0]!.id), {
               q: params.query,
@@ -227,7 +229,7 @@ export function registerRepositoryTools(server: McpServer, client: TaigaClient)
           githubRepositoryId: params.githubRepositoryId,
           ...(params.replacesRepositoryId ? { replacesRepositoryId: params.replacesRepositoryId } : {}),
         });
-        return toolResult(pickFields([linked.data as Row], LINK_FIELDS)[0]);
+        return toolResult(pickFields([linked.data], LINK_FIELDS)[0]);
       })
   );
 
@@ -265,7 +267,7 @@ export function registerRepositoryTools(server: McpServer, client: TaigaClient)
             ...(params.baseBranch !== undefined ? { baseBranch: params.baseBranch } : {}),
             ...(params.label !== undefined ? { label: params.label } : {}),
           })
-        ).data as Row;
+        ).data;
         return toolResult({
           ...pickFields([updated], LINK_FIELDS)[0],
           baseBranchProtection: updated.baseBranchProtection ?? null,

package/src/tools/resources.ts

@@ -16,7 +16,6 @@ import {
   productDocumentName,
   type ProductDocumentOrigin,
   type ProductDocumentType,
-  type ProductSettingsView,
 } from './catalogue.js';
 import { productId as productIdInput } from './inputs.js';
 import { mimeTypeOf, renderDocument } from './markdown.js';
@@ -69,9 +68,7 @@ async function served<T>(read: Promise<T>, miss: string): Promise<T> {
 export function registerResources(server: McpServer, client: TaigaClient) {
   if (client.hasCapability('tenant:documents:read')) {
     const published = async () =>
-      ((await client.listTenantDocuments({ limit: 100 })).data as Record<string, unknown>[]).filter(
-        (row) => row.isDraft === false
-      );
+      (await client.listTenantDocuments({ limit: 100 })).data.filter((row) => row.isDraft === false);
 
     server.registerResource(
       'organization-document',
@@ -95,7 +92,7 @@ export function registerResources(server: McpServer, client: TaigaClient) {
           'tone of voice or the standing instructions. Sections rendered as headings.',
       },
       async (uri, variables) => {
-        const type = requireOneOf('Document type', String(variables.type), TENANT_DOCUMENT_TYPES);
+        const type = requireOneOf('Document type', String(variables['type']), TENANT_DOCUMENT_TYPES);
         try {
           return contents(uri.href, (await client.getTenantDocument(type)).data);
         } catch (error) {
@@ -127,7 +124,7 @@ export function registerResources(server: McpServer, client: TaigaClient) {
           'section map, JSON otherwise (the read says which).',
       },
       async (uri, variables) => {
-        const factoryId = requireId('Factory ID', String(variables.factoryId));
+        const factoryId = requireId('Factory ID', String(variables['factoryId']));
         const doc = await served(
           client.getFactoryDocument(factoryId, FACTORY_DOCUMENT_TYPES[0]),
           'This factory has not published instructions, or the key cannot see the factory'
@@ -147,7 +144,7 @@ export function registerResources(server: McpServer, client: TaigaClient) {
         client.getProductDocument(productId, type, origin),
         `No published ${origin} ${type} for this product, or the key cannot see it; taiga_list_product_documents shows what exists`
       );
-      return contents(uri.href, { name: productDocumentName(type), ...(result.data as Record<string, unknown>) });
+      return contents(uri.href, { name: productDocumentName(type), ...result.data });
     };
 
     // The timeline template first: the SDK tries templates in registration
@@ -162,9 +159,9 @@ export function registerResources(server: McpServer, client: TaigaClient) {
           'Markdown for a section map, JSON otherwise (the read says which).',
       },
       async (uri, variables) => {
-        const productId = requireId('Product ID', String(variables.productId));
-        const type = documentType(String(variables.type));
-        const origin = requireOneOf('Origin', String(variables.origin), PRODUCT_DOCUMENT_ORIGINS);
+        const productId = requireId('Product ID', String(variables['productId']));
+        const type = documentType(String(variables['type']));
+        const origin = requireOneOf('Origin', String(variables['origin']), PRODUCT_DOCUMENT_ORIGINS);
         return read(uri, productId, type, origin);
       }
     );
@@ -181,14 +178,14 @@ export function registerResources(server: McpServer, client: TaigaClient) {
           'otherwise (the read says which).',
       },
       async (uri, variables) => {
-        const productId = requireId('Product ID', String(variables.productId));
-        const type = documentType(String(variables.type));
+        const productId = requireId('Product ID', String(variables['productId']));
+        const type = documentType(String(variables['type']));
         const product = (
           await served(
             client.getProduct(productId),
             'No product with that ID the key can see; taiga_list_products shows them'
           )
-        ).data as ProductSettingsView;
+        ).data;
         return read(uri, productId, type, defaultOriginFor(product, type));
       }
     );
@@ -197,20 +194,20 @@ export function registerResources(server: McpServer, client: TaigaClient) {
   if (client.hasCapability('backlog:read')) {
     server.registerResource(
       'backlog-item',
-      new ResourceTemplate('taiga://backlog/{itemId}', { list: undefined }),
+      new ResourceTemplate('taiga://initiatives/{initiativeId}', { list: undefined }),
       {
-        title: 'Backlog item',
+        title: 'Initiative',
         description:
-          'An initiative in full: description, acceptance criteria, technical context. taiga_list_backlog_items ' +
+          'An initiative in full: description, acceptance criteria, technical context. taiga_list_initiatives ' +
           'gives the item ID.',
         mimeType: 'application/json',
       },
       async (uri, variables) => {
-        const itemId = requireId('Backlog item ID', String(variables.itemId));
+        const initiativeId = requireId('Initiative ID', String(variables['initiativeId']));
         const item = (
           await served(
-            client.getBacklogItem(itemId),
-            'No backlog item with that ID the key can see; taiga_list_backlog_items shows what exists'
+            client.getBacklogItem(initiativeId),
+            'No initiative with that ID the key can see; taiga_list_initiatives shows what exists'
           )
         ).data;
         return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(item, null, 2) }] };

package/src/tools/sections.test.ts

@@ -50,12 +50,12 @@ describe('applySectionEdit', () => {
   });
 
   it('turns a bare-string or array-valued section into an object with the new text', () => {
-    expect(applySectionEdit(sections, 'scope', 'new').scope).toEqual({ content: 'new' });
-    expect(applySectionEdit(sections, 'list', 'new').list).toEqual({ content: 'new' });
+    expect(applySectionEdit(sections, 'scope', 'new')['scope']).toEqual({ content: 'new' });
+    expect(applySectionEdit(sections, 'list', 'new')['list']).toEqual({ content: 'new' });
   });
 
   it('adds a section that did not exist', () => {
-    expect(applySectionEdit(sections, 'retention', 'keep 90 days').retention).toEqual({ content: 'keep 90 days' });
+    expect(applySectionEdit(sections, 'retention', 'keep 90 days')['retention']).toEqual({ content: 'keep 90 days' });
   });
 
   it('does not mutate its input', () => {