@dpesch/mantisbt-mcp-server 1.7.0 → 1.8.0

package/docs/cookbook.md

@@ -46,6 +46,10 @@ Tool-oriented recipes for the MantisBT MCP server — each recipe shows exactly
   - [Search with field enrichment](#search-with-field-enrichment)
 - [Projects & Categories](#projects--categories)
   - [List project categories](#list-project-categories)
+  - [Find a project member](#find-a-project-member)
+- [Metadata](#metadata)
+  - [Get a metadata summary](#get-a-metadata-summary)
+  - [Get the full metadata cache](#get-the-full-metadata-cache)
 - [Version & Diagnostics](#version--diagnostics)
   - [Get MCP server version](#get-mcp-server-version)
   - [Get MantisBT version](#get-mantis-version)
@@ -53,6 +57,7 @@ Tool-oriented recipes for the MantisBT MCP server — each recipe shows exactly
 - [Resources](#resources)
   - [Read the current user profile](#read-the-current-user-profile)
   - [Read all projects](#read-all-projects)
+  - [Read a single project with all details](#read-a-single-project-with-all-details)
   - [Read issue enum values](#read-issue-enum-values)
 - [Prompts](#prompts)
   - [Create a bug report](#create-a-bug-report)
@@ -1079,7 +1084,7 @@ Read `tags[].id` from the response.
 "Tag #14 successfully removed from issue #1042."
 ```
 
-> **Note:** `detach_tag` requires a numeric ID, not the tag name. There is no lookup by name — always retrieve the ID first via `get_issue` or `get_metadata`.
+> **Note:** `detach_tag` requires a numeric ID, not the tag name. There is no lookup by name — always retrieve the ID first via `get_issue` or `list_tags`.
 
 ---
 
@@ -1338,6 +1343,123 @@ Returns all categories available for a MantisBT project. Use the returned names
 
 ---
 
+### Find a project member
+
+Searches project members by name, real name, or email. The search is case-insensitive and matches any substring. Results are served from the metadata cache when available; falls back to a live API call on a cold cache.
+
+**Tool:** `find_project_member`
+
+**Parameters:**
+- `project_id` — numeric project ID
+- `query` — _(optional)_ substring to match against `name`, `real_name`, or `email`
+- `limit` — _(optional)_ maximum number of results, default 10, max 100
+
+**Request:**
+
+```json
+{
+  "project_id": 3,
+  "query": "smith",
+  "limit": 5
+}
+```
+
+**Response:**
+
+```json
+[
+  { "id": 4, "name": "jsmith", "real_name": "John Smith", "email": "jsmith@example.com", "access_level": { "id": 55, "name": "developer" } },
+  { "id": 11, "name": "asmith", "real_name": "Alice Smith", "email": "asmith@example.com", "access_level": { "id": 40, "name": "reporter" } }
+]
+```
+
+> **Tip:** Omit `query` to list all members of the project (up to `limit`).
+
+---
+
+## Metadata
+
+### Get a metadata summary
+
+Returns a compact overview of all cached metadata: total project and tag counts, and per-project counts for users, versions, and categories. Use this to get a quick overview without transferring large arrays.
+
+**Tool:** `get_metadata`
+
+**Parameters:** _(none)_
+
+**Request:**
+
+```json
+{}
+```
+
+**Response:**
+
+```json
+{
+  "projects": 24,
+  "tags": 15,
+  "byProject": {
+    "3": { "name": "Webshop", "users": 8, "versions": 12, "categories": 4 },
+    "5": { "name": "Backend API", "users": 5, "versions": 7, "categories": 3 }
+  },
+  "cached_at": "2026-03-27T09:00:00.000Z",
+  "ttl_seconds": 82800
+}
+```
+
+> **Note:** For full lists use `list_projects`, `get_project_users`, `get_project_versions`, `get_project_categories`, `list_tags`, or `get_metadata_full`.
+
+---
+
+### Get the full metadata cache
+
+Returns the complete raw metadata cache as minified JSON. Contains all projects with their full field set, plus users, versions, and categories per project, and all tags. Use this when you need the complete data in a single call.
+
+**Tool:** `get_metadata_full`
+
+**Parameters:** _(none)_
+
+**Request:**
+
+```json
+{}
+```
+
+**Response:**
+
+```json
+{
+  "projects": [
+    {
+      "id": 3,
+      "name": "Webshop",
+      "status": { "id": 10, "name": "development" },
+      "enabled": true,
+      "users": [
+        { "id": 4, "name": "jsmith", "real_name": "John Smith", "email": "jsmith@example.com", "access_level": { "id": 55, "name": "developer" } }
+      ],
+      "versions": [
+        { "id": 21, "name": "2.4.0", "released": false, "obsolete": false }
+      ],
+      "categories": [
+        { "id": 1, "name": "General" },
+        { "id": 2, "name": "UI" }
+      ]
+    }
+  ],
+  "tags": [
+    { "id": 1, "name": "regression" },
+    { "id": 2, "name": "hotfix" }
+  ],
+  "cached_at": "2026-03-27T09:00:00.000Z"
+}
+```
+
+> **Tip:** `get_metadata` provides the same data as a compact summary (counts only). Use `get_metadata_full` when you need the actual arrays.
+
+---
+
 ## Version & Diagnostics
 
 ### Get MCP server version
@@ -1476,6 +1598,41 @@ Returns all MantisBT projects accessible with the configured API key.
 
 ---
 
+### Read a single project with all details
+
+Returns a combined view of a single project: its fields plus all members, versions, and categories in one call. Served from the metadata cache when available; falls back to three parallel API calls on a cold cache. Clients that support Resource list can enumerate all available project URIs.
+
+**Resource URI:** `mantis://projects/{id}` (replace `{id}` with the numeric project ID)
+
+**Fetch behaviour:** Cache-first (MetadataCache, default TTL 24 h). Falls back to live API calls when the cache is empty.
+
+**Example URI:** `mantis://projects/42`
+
+**Response:**
+
+```json
+{
+  "id": 3,
+  "name": "Webshop",
+  "status": { "id": 10, "name": "development" },
+  "enabled": true,
+  "users": [
+    { "id": 4, "name": "jsmith", "real_name": "John Smith", "email": "jsmith@example.com", "access_level": { "id": 55, "name": "developer" } }
+  ],
+  "versions": [
+    { "id": 21, "name": "2.4.0", "released": false, "obsolete": false }
+  ],
+  "categories": [
+    { "id": 1, "name": "General" },
+    { "id": 2, "name": "UI" }
+  ]
+}
+```
+
+> **Tip:** Use `mantis://projects` to get a compact list of all projects, then fetch individual project details via `mantis://projects/{id}`.
+
+---
+
 ### Read issue enum values
 
 Returns valid ID/name pairs for all issue enum fields (severity, priority, status, resolution, reproducibility). Use this to look up canonical English names before calling `create_issue` or `update_issue`.

package/docs/examples.de.md

@@ -93,6 +93,10 @@ Praktische Beispiele für die Interaktion mit MantisBT über Claude, sobald der
 
 > »Wer sind die Mitglieder des API-Projekts?«
 
+> »Gibt es im Projekt 3 einen Benutzer namens 'schmidt'?«
+
+> »Finde alle Mitglieder des Webshop-Projekts, deren E-Mail '@example.com' enthält.«
+
 ---
 
 ### Triage und Auswertung
@@ -187,6 +191,8 @@ MCP-Ressourcen sind URI-adressierbare, schreibgeschützte Daten, die Clients dir
 
 > »Rufe `mantis://projects` ab, um die Liste der verfügbaren Projekte zu erhalten.«
 
+> »Lese `mantis://projects/3`, um alle Details des Webshop-Projekts zu sehen: Mitglieder, Versionen und Kategorien in einem Aufruf.«
+
 > »Lade `mantis://enums`, um die gültigen Severity- und Priority-Werte einzusehen, bevor ein Issue erstellt wird.«
 
 ### Alternative Tools für Clients ohne Ressourcen-Unterstützung

package/docs/examples.md

@@ -93,6 +93,10 @@ Practical examples of how to interact with MantisBT through Claude once the MCP
 
 > "Who are the members of the API project?"
 
+> "Is there a user named 'smith' in project 3?"
+
+> "Find all members of the Webshop project whose email contains '@example.com'."
+
 ---
 
 ### Triage and reporting
@@ -187,6 +191,8 @@ MCP Resources are URI-addressable, read-only data that clients can fetch directl
 
 > "Fetch `mantis://projects` to get the list of available projects."
 
+> "Read `mantis://projects/3` to see all details of the Webshop project: members, versions, and categories in one call."
+
 > "Load `mantis://enums` to see valid severity and priority values before creating an issue."
 
 ### Equivalent tool fallbacks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dpesch/mantisbt-mcp-server",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "mcpName": "io.github.dpesch/mantisbt-mcp-server",
   "description": "MCP server for MantisBT REST API – read and manage bug tracker issues",
   "author": "Dominik Pesch",

package/server.json

@@ -3,12 +3,12 @@
   "name": "io.github.dpesch/mantisbt-mcp-server",
   "title": "MantisBT MCP Server",
   "description": "MantisBT MCP server – manage issues, notes, files, tags, and relationships. With semantic search.",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@dpesch/mantisbt-mcp-server",
-      "version": "1.7.0",
+      "version": "1.8.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/tests/helpers/mock-server.ts

@@ -39,7 +39,21 @@ export interface ResourceResult {
 
 type PromptHandler = (args: Record<string, unknown>) => PromptResult;
 
-type ResourceHandler = (uri: URL) => Promise<ResourceResult>;
+type ResourceHandler = (uri: URL, variables?: Record<string, string>) => Promise<ResourceResult>;
+
+interface ResourceEntry {
+  handler: ResourceHandler;
+  /** URI template pattern, e.g. 'mantis://projects/{id}'. Present for template resources only. */
+  template?: string;
+}
+
+function matchTemplate(template: string, uri: string): Record<string, string> | null {
+  const names = [...template.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]!);
+  const pattern = template.replace(/\{[^}]+\}/g, '([^/]+)');
+  const match = uri.match(new RegExp(`^${pattern}$`));
+  if (!match) return null;
+  return Object.fromEntries(names.map((name, i) => [name, match[i + 1]!]));
+}
 
 interface PromptDefinition {
   argsSchema?: Record<string, z.ZodTypeAny>;
@@ -50,7 +64,7 @@ export class MockMcpServer {
   private readonly handlers = new Map<string, ToolHandler>();
   private readonly schemas = new Map<string, z.ZodTypeAny>();
   private readonly promptHandlers = new Map<string, PromptHandler>();
-  private readonly resourceHandlers = new Map<string, ResourceHandler>();
+  private readonly resourceEntries = new Map<string, ResourceEntry>();
 
   // Nachahmt McpServer.registerTool – fängt Handler und Schema ein
   registerTool(name: string, definition: ToolDefinition, handler: ToolHandler): void {
@@ -78,16 +92,17 @@ export class MockMcpServer {
     const handler = this.handlers.get(name);
     if (!handler) throw new Error(`Tool not registered: ${name}`);
 
-    if (options.validate) {
-      const schema = this.schemas.get(name);
-      if (schema) {
-        const parsed = schema.safeParse(args);
-        if (!parsed.success) {
+    const schema = this.schemas.get(name);
+    if (schema) {
+      const parsed = schema.safeParse(args);
+      if (!parsed.success) {
+        if (options.validate) {
           return {
             content: [{ type: 'text', text: `Validation error: ${parsed.error.message}` }],
             isError: true,
           };
         }
+      } else {
         return handler(parsed.data as Record<string, unknown>);
       }
     }
@@ -117,21 +132,35 @@ export class MockMcpServer {
     return [...this.promptHandlers.keys()];
   }
 
-  registerResource(name: string, uri: string, _config: unknown, handler: ResourceHandler): void {
-    this.resourceHandlers.set(uri, handler);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  registerResource(name: string, uriOrTemplate: any, _config: unknown, handler: ResourceHandler): void {
+    if (typeof uriOrTemplate === 'string') {
+      this.resourceEntries.set(uriOrTemplate, { handler });
+    } else {
+      // ResourceTemplate — uriTemplate getter returns a UriTemplate object; .toString() gives the pattern string
+      const templateStr: string = uriOrTemplate.uriTemplate?.toString() ?? name;
+      this.resourceEntries.set(templateStr, { handler, template: templateStr });
+    }
   }
 
   async callResource(uri: string): Promise<ResourceResult> {
-    const handler = this.resourceHandlers.get(uri);
-    if (!handler) throw new Error(`Resource not registered: ${uri}`);
-    return handler(new URL(uri));
+    const exact = this.resourceEntries.get(uri);
+    if (exact) return exact.handler(new URL(uri), {});
+
+    for (const entry of this.resourceEntries.values()) {
+      if (!entry.template) continue;
+      const variables = matchTemplate(entry.template, uri);
+      if (variables) return entry.handler(new URL(uri), variables);
+    }
+
+    throw new Error(`Resource not registered: ${uri}`);
   }
 
   hasResourceRegistered(uri: string): boolean {
-    return this.resourceHandlers.has(uri);
+    return this.resourceEntries.has(uri);
   }
 
   registeredResourceUris(): string[] {
-    return [...this.resourceHandlers.keys()];
+    return [...this.resourceEntries.keys()];
   }
 }

package/tests/resources/resources.test.ts

@@ -15,6 +15,20 @@ const PROJECTS_FIXTURE = [
   { id: 11, name: 'Beta',  enabled: true },
 ];
 
+// Simulates a raw MantisBT API response with extra fields that must be stripped
+const PROJECTS_RAW_FIXTURE = [
+  {
+    id: 10,
+    name: 'Alpha',
+    enabled: true,
+    status: { id: 10, name: 'development', label: 'Entwicklung' },
+    view_state: { id: 10, name: 'public', label: 'Öffentlich' },
+    custom_fields: [
+      { id: 1, name: 'Reklamieren', type: 'checkbox', default_value: '', possible_values: 'Ja' },
+    ],
+  },
+];
+
 const ENUM_FIXTURE = {
   configs: [
     { option: 'severity_enum_string',        value: '10:feature,50:minor,80:block' },
@@ -129,6 +143,33 @@ describe('mantis://projects', () => {
     expect(parsed).toHaveLength(2);
   });
 
+  it('returns minified JSON (no indentation)', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
+
+    const result = await mockServer.callResource('mantis://projects');
+
+    expect(result.contents[0]!.text).not.toContain('\n');
+  });
+
+  it('strips custom_fields from live API response', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_RAW_FIXTURE })));
+
+    const result = await mockServer.callResource('mantis://projects');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).not.toHaveProperty('custom_fields');
+  });
+
+  it('preserves label on status and view_state from live API response', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_RAW_FIXTURE })));
+
+    const result = await mockServer.callResource('mantis://projects');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as Array<Record<string, unknown>>;
+    expect((parsed[0]!['status'] as Record<string, unknown>)['label']).toBe('Entwicklung');
+    expect((parsed[0]!['view_state'] as Record<string, unknown>)['label']).toBe('Öffentlich');
+  });
+
   it('serves from cache without calling the API when cache is valid', async () => {
     await cache.save({
       timestamp: Date.now(),
@@ -145,6 +186,82 @@ describe('mantis://projects', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// mantis://projects/{id}
+// ---------------------------------------------------------------------------
+
+describe('mantis://projects/{id}', () => {
+  it('registers the template resource', () => {
+    expect(mockServer.hasResourceRegistered('mantis://projects/{id}')).toBe(true);
+  });
+
+  it('returns combined project view from cache (users, versions, categories)', async () => {
+    const projectsFixture = [{ id: 10, name: 'Alpha', enabled: true }];
+    await cache.save({
+      timestamp: Date.now(),
+      projects: projectsFixture,
+      byProject: {
+        10: {
+          users: [{ id: 1, name: 'jsmith' }],
+          versions: [{ id: 5, name: '1.0.0', released: true }],
+          categories: [{ id: 3, name: 'Bugs' }],
+        },
+      },
+      tags: [],
+    });
+
+    const result = await mockServer.callResource('mantis://projects/10');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, unknown>;
+    expect(parsed['id']).toBe(10);
+    expect(parsed['name']).toBe('Alpha');
+    expect(parsed['users']).toHaveLength(1);
+    expect(parsed['versions']).toHaveLength(1);
+    expect(parsed['categories']).toHaveLength(1);
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+  });
+
+  it('fetches live data in parallel when cache is cold', async () => {
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ projects: [{ id: 10, name: 'Alpha', categories: [{ id: 3, name: 'Bugs' }] }] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ users: [{ id: 1, name: 'jsmith' }] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ versions: [{ id: 5, name: '1.0.0' }] })));
+
+    const result = await mockServer.callResource('mantis://projects/10');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, unknown>;
+    expect(parsed['id']).toBe(10);
+    expect((parsed['users'] as unknown[]).length).toBeGreaterThan(0);
+    expect((parsed['versions'] as unknown[]).length).toBeGreaterThan(0);
+    expect((parsed['categories'] as unknown[]).length).toBeGreaterThan(0);
+  });
+
+  it('strips [All Projects] prefix from category names on live fetch', async () => {
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ projects: [{ id: 10, name: 'Alpha', categories: [{ id: 1, name: '[All Projects] General' }] }] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ users: [] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ versions: [] })));
+
+    const result = await mockServer.callResource('mantis://projects/10');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as { categories: Array<{ name: string }> };
+    expect(parsed.categories[0]!.name).toBe('General');
+  });
+
+  it('returns minified JSON', async () => {
+    await cache.save({
+      timestamp: Date.now(),
+      projects: [{ id: 10, name: 'Alpha' }],
+      byProject: { 10: { users: [], versions: [], categories: [] } },
+      tags: [],
+    });
+
+    const result = await mockServer.callResource('mantis://projects/10');
+
+    expect(result.contents[0]!.text).not.toContain('\n');
+  });
+});
+
 // ---------------------------------------------------------------------------
 // mantis://enums
 // ---------------------------------------------------------------------------

package/tests/tools/metadata.test.ts

@@ -93,8 +93,46 @@ describe('get_metadata', () => {
     expect(result.isError).toBeUndefined();
     // fetch must NOT have been called — data came from cache
     expect(fetch).not.toHaveBeenCalled();
-    const parsed = JSON.parse(result.content[0]!.text) as CachedMetadata;
-    expect(parsed.projects).toEqual(metadata.projects);
+    const parsed = JSON.parse(result.content[0]!.text) as { projects: number };
+    expect(parsed.projects).toBe(1);
+  });
+
+  it('returns compact summary (no raw arrays)', async () => {
+    const metadata = makeSampleMetadata();
+    vi.mocked(readFile).mockResolvedValue(makeValidMetadataCacheFile(metadata) as any);
+
+    const result = await mockServer.callTool('get_metadata', {});
+    const parsed = JSON.parse(result.content[0]!.text) as Record<string, unknown>;
+    expect(typeof parsed['projects']).toBe('number');
+    expect(typeof parsed['tags']).toBe('number');
+    expect(Array.isArray(parsed['projects'])).toBe(false);
+  });
+
+  it('byProject contains name and counts per project', async () => {
+    const metadata: CachedMetadata = {
+      timestamp: Date.now(),
+      projects: [{ id: 1, name: 'Test Project' }],
+      byProject: { 1: { users: [{ id: 1, name: 'u' }], versions: [{ id: 1, name: 'v1' }], categories: [{ id: 1, name: 'c' }, { id: 2, name: 'c2' }] } },
+      tags: [],
+    };
+    vi.mocked(readFile).mockResolvedValue(makeValidMetadataCacheFile(metadata) as any);
+
+    const result = await mockServer.callTool('get_metadata', {});
+    const parsed = JSON.parse(result.content[0]!.text) as { byProject: Record<string, { name: string; users: number; versions: number; categories: number }> };
+    const entry = Object.values(parsed.byProject)[0]!;
+    expect(typeof entry.name).toBe('string');
+    expect(typeof entry.users).toBe('number');
+    expect(typeof entry.versions).toBe('number');
+    expect(typeof entry.categories).toBe('number');
+  });
+
+  it('ttl_seconds is positive for fresh cache', async () => {
+    const metadata = makeSampleMetadata();
+    vi.mocked(readFile).mockResolvedValue(makeValidMetadataCacheFile(metadata) as any);
+
+    const result = await mockServer.callTool('get_metadata', {});
+    const parsed = JSON.parse(result.content[0]!.text) as { ttl_seconds: number };
+    expect(parsed.ttl_seconds).toBeGreaterThan(0);
   });
 
   it('fetches and caches when cache is missing', async () => {
@@ -118,6 +156,42 @@ describe('get_metadata', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// get_metadata_full
+// ---------------------------------------------------------------------------
+
+describe('get_metadata_full', () => {
+  it('is registered', () => {
+    expect(mockServer.hasToolRegistered('get_metadata_full')).toBe(true);
+  });
+
+  it('returns full raw cache (arrays, not counts)', async () => {
+    const metadata = makeSampleMetadata();
+    vi.mocked(readFile).mockResolvedValue(makeValidMetadataCacheFile(metadata) as any);
+
+    const result = await mockServer.callTool('get_metadata_full', {});
+    const parsed = JSON.parse(result.content[0]!.text) as { projects: unknown[]; tags: unknown[] };
+    expect(Array.isArray(parsed.projects)).toBe(true);
+    expect(Array.isArray(parsed.tags)).toBe(true);
+  });
+
+  it('returns minified JSON (no newlines)', async () => {
+    const metadata = makeSampleMetadata();
+    vi.mocked(readFile).mockResolvedValue(makeValidMetadataCacheFile(metadata) as any);
+
+    const result = await mockServer.callTool('get_metadata_full', {});
+    expect(result.content[0]!.text).not.toContain('\n');
+  });
+
+  it('uses cache without fetching', async () => {
+    const metadata = makeSampleMetadata();
+    vi.mocked(readFile).mockResolvedValue(makeValidMetadataCacheFile(metadata) as any);
+
+    await mockServer.callTool('get_metadata_full', {});
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // sync_metadata
 // ---------------------------------------------------------------------------
@@ -158,6 +232,58 @@ describe('sync_metadata', () => {
     expect(written.data.tags).toHaveLength(2);
   });
 
+  it('strips custom_fields from projects before writing to cache', async () => {
+    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+    vi.mocked(mkdir).mockResolvedValue(undefined);
+    vi.mocked(writeFile).mockResolvedValue(undefined);
+
+    const projectsResponse = {
+      projects: [{
+        id: 1,
+        name: 'Test Project',
+        status: { id: 10, name: 'development', label: 'Entwicklung' },
+        custom_fields: [{ id: 6, name: 'Reklamieren', type: 'checkbox' }],
+      }],
+    };
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify(projectsResponse)))
+      .mockResolvedValue(makeResponse(200, JSON.stringify({ users: [], versions: [], projects: [{ id: 1, categories: [] }], tags: [] })));
+
+    await mockServer.callTool('sync_metadata', {});
+
+    const writeCall = vi.mocked(writeFile).mock.calls.find(call => String(call[0]).includes('metadata.json'));
+    const written = JSON.parse(writeCall![1] as string) as { data: { projects: Array<Record<string, unknown>> } };
+    expect(written.data.projects[0]).not.toHaveProperty('custom_fields');
+  });
+
+  it('preserves label on status and view_state when writing to cache', async () => {
+    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+    vi.mocked(mkdir).mockResolvedValue(undefined);
+    vi.mocked(writeFile).mockResolvedValue(undefined);
+
+    const projectsResponse = {
+      projects: [{
+        id: 1,
+        name: 'Test Project',
+        status: { id: 10, name: 'development', label: 'Entwicklung' },
+        view_state: { id: 10, name: 'public', label: 'Öffentlich' },
+      }],
+    };
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify(projectsResponse)))
+      .mockResolvedValue(makeResponse(200, JSON.stringify({ users: [], versions: [], projects: [{ id: 1, categories: [] }], tags: [] })));
+
+    await mockServer.callTool('sync_metadata', {});
+
+    const writeCall = vi.mocked(writeFile).mock.calls.find(call => String(call[0]).includes('metadata.json'));
+    const written = JSON.parse(writeCall![1] as string) as { data: { projects: Array<Record<string, unknown>> } };
+    const project = written.data.projects[0]!;
+    expect((project['status'] as Record<string, unknown>)['label']).toBe('Entwicklung');
+    expect((project['view_state'] as Record<string, unknown>)['label']).toBe('Öffentlich');
+  });
+
   it('fetches versions with obsolete=1 and inherit=1', async () => {
     vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
     vi.mocked(mkdir).mockResolvedValue(undefined);