@dpesch/mantisbt-mcp-server 1.10.3 → 1.11.0

package/tests/tools/issues.test.ts

@@ -1,1180 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { readFileSync, existsSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { MantisClient } from '../../src/client.js';
-import { registerIssueTools } from '../../src/tools/issues.js';
-import { MetadataCache } from '../../src/cache.js';
-import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
-import { MANTIS_RESOLVED_STATUS_ID } from '../../src/constants.js';
-import { clearIssueEnumCache } from '../../src/tools/config.js';
-
-function makeStubCache(projectUsers?: Array<{ id: number; name: string; real_name?: string }>): MetadataCache {
-  return {
-    loadIfValid: vi.fn(async () => projectUsers ? {
-      timestamp: Date.now(),
-      projects: [],
-      tags: [],
-      byProject: { 1: { users: projectUsers, versions: [], categories: [] } },
-    } : null),
-  } as unknown as MetadataCache;
-}
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const fixturesDir = join(__dirname, '..', 'fixtures');
-
-// ---------------------------------------------------------------------------
-// Fixtures laden (mit Inline-Fallback)
-// ---------------------------------------------------------------------------
-
-const getIssueFixturePath = join(fixturesDir, 'get_issue.json');
-const listIssuesFixturePath = join(fixturesDir, 'list_issues.json');
-
-const getIssueFixture = existsSync(getIssueFixturePath)
-  ? (JSON.parse(readFileSync(getIssueFixturePath, 'utf-8')) as { issues: Array<{ id: number; summary: string; notes?: Array<{ id: number }> }> })
-  : { issues: [{ id: 42, summary: 'Test Issue' }] };
-
-const listIssuesFixture = existsSync(listIssuesFixturePath)
-  ? (JSON.parse(readFileSync(listIssuesFixturePath, 'utf-8')) as { issues: Array<{ id: number; summary: string; status: { id: number; name: string } }>; total_count: number })
-  : { issues: [{ id: 42, summary: 'Test Issue', status: { id: 80, name: 'resolved' } }], total_count: 1 };
-
-const recordedListIssuesPath = join(fixturesDir, 'recorded', 'list_issues.json');
-const recordedListIssuesFixture = existsSync(recordedListIssuesPath)
-  ? (JSON.parse(readFileSync(recordedListIssuesPath, 'utf-8')) as { issues: Array<{ id: number; summary: string; status: { id: number; name: string } }> })
-  : null;
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-let mockServer: MockMcpServer;
-let client: MantisClient;
-
-beforeEach(() => {
-  mockServer = new MockMcpServer();
-  client = new MantisClient('https://mantis.example.com', 'test-token');
-  registerIssueTools(mockServer as never, client, makeStubCache());
-  vi.stubGlobal('fetch', vi.fn());
-  clearIssueEnumCache();
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-// ---------------------------------------------------------------------------
-// get_issue
-// ---------------------------------------------------------------------------
-
-describe('get_issue', () => {
-  it('ist registriert', () => {
-    expect(mockServer.hasToolRegistered('get_issue')).toBe(true);
-  });
-
-  it('gibt issue-Daten aus der Fixture zurück', async () => {
-    const issueId = getIssueFixture.issues[0]!.id;
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(getIssueFixture)));
-
-    const result = await mockServer.callTool('get_issue', { id: issueId });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { id: number };
-    expect(parsed.id).toBe(issueId);
-  });
-
-  it('ruft den richtigen Endpoint auf', async () => {
-    const issueId = getIssueFixture.issues[0]!.id;
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(getIssueFixture)));
-
-    await mockServer.callTool('get_issue', { id: issueId });
-
-    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-    expect(calledUrl).toContain(`issues/${issueId}`);
-  });
-
-  it('gibt isError: true bei 404 zurück', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(404, JSON.stringify({ message: 'Issue not found' })),
-    );
-
-    const result = await mockServer.callTool('get_issue', { id: 9999 });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('Error:');
-  });
-
-  it('enthält notes direkt in der Response (kein separater list_notes-Call nötig)', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(getIssueFixture)));
-
-    const result = await mockServer.callTool('get_issue', { id: getIssueFixture.issues[0]!.id });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { notes?: Array<{ id: number }> };
-    const fixtureNotes = getIssueFixture.issues[0]!.notes!;
-    expect(Array.isArray(parsed.notes)).toBe(true);
-    expect(parsed.notes!.length).toBe(fixtureNotes.length);
-    expect(parsed.notes![0]!.id).toBe(fixtureNotes[0]!.id);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// get_issues
-// ---------------------------------------------------------------------------
-
-describe('get_issues', () => {
-  it('ist registriert', () => {
-    expect(mockServer.hasToolRegistered('get_issues')).toBe(true);
-  });
-
-  it('gibt ein Array von Issues zurück wenn alle IDs existieren', async () => {
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 42, summary: 'Issue 42' }] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 43, summary: 'Issue 43' }] })));
-
-    const result = await mockServer.callTool('get_issues', { ids: [42, 43] });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as {
-      issues: Array<{ id: number } | null>;
-      requested: number;
-      found: number;
-      failed: number;
-    };
-    expect(parsed.requested).toBe(2);
-    expect(parsed.found).toBe(2);
-    expect(parsed.failed).toBe(0);
-    expect(parsed.issues[0]?.id).toBe(42);
-    expect(parsed.issues[1]?.id).toBe(43);
-  });
-
-  it('gibt null für nicht gefundene IDs zurück ohne isError zu setzen', async () => {
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 42, summary: 'Issue 42' }] })))
-      .mockResolvedValueOnce(makeResponse(404, JSON.stringify({ message: 'Issue not found' })));
-
-    const result = await mockServer.callTool('get_issues', { ids: [42, 9999] });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as {
-      issues: Array<{ id: number } | null>;
-      found: number;
-      failed: number;
-    };
-    expect(parsed.found).toBe(1);
-    expect(parsed.failed).toBe(1);
-    expect(parsed.issues[0]?.id).toBe(42);
-    expect(parsed.issues[1]).toBeNull();
-  });
-
-  it('gibt isError nicht zurück auch wenn alle IDs fehlschlagen', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(404, JSON.stringify({ message: 'Not found' })),
-    );
-
-    const result = await mockServer.callTool('get_issues', { ids: [9001, 9002] });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as {
-      issues: Array<null>;
-      found: number;
-      failed: number;
-    };
-    expect(parsed.found).toBe(0);
-    expect(parsed.failed).toBe(2);
-    expect(parsed.issues).toEqual([null, null]);
-  });
-
-  it('erhält die Reihenfolge der Input-IDs im Ergebnis-Array', async () => {
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 10, summary: 'A' }] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 20, summary: 'B' }] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 30, summary: 'C' }] })));
-
-    const result = await mockServer.callTool('get_issues', { ids: [10, 20, 30] });
-
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
-    expect(parsed.issues.map((i) => i.id)).toEqual([10, 20, 30]);
-  });
-
-  it('validiert: leeres ids-Array wird abgelehnt', async () => {
-    const result = await mockServer.callTool('get_issues', { ids: [] }, { validate: true });
-    expect(result.isError).toBe(true);
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-  });
-
-  it('validiert: mehr als 50 IDs werden abgelehnt', async () => {
-    const ids = Array.from({ length: 51 }, (_, i) => i + 1);
-    const result = await mockServer.callTool('get_issues', { ids }, { validate: true });
-    expect(result.isError).toBe(true);
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-  });
-
-  it('akzeptiert String-IDs via z.coerce', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issues: [{ id: 42, summary: 'Test' }] })),
-    );
-
-    const result = await mockServer.callTool('get_issues', { ids: ['42'] }, { validate: true });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
-    expect(parsed.issues[0]?.id).toBe(42);
-  });
-
-  it('führt alle Requests aus (Concurrency-Nachweis mit 6 IDs)', async () => {
-    Array.from({ length: 6 }, (_, i) => {
-      vi.mocked(fetch).mockResolvedValueOnce(
-        makeResponse(200, JSON.stringify({ issues: [{ id: i + 1, summary: 'x' }] })),
-      );
-    });
-
-    const result = await mockServer.callTool('get_issues', { ids: [1, 2, 3, 4, 5, 6] });
-
-    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(6);
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { requested: number };
-    expect(parsed.requested).toBe(6);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// create_issue
-// ---------------------------------------------------------------------------
-
-describe('create_issue', () => {
-  it('ist registriert', () => {
-    expect(mockServer.hasToolRegistered('create_issue')).toBe(true);
-  });
-
-  it('sends severity as { id: 50 } (minor) by default when no severity is provided', async () => {
-    // Regression: omitting severity caused MantisBT to store 0 → displayed as "@0@".
-    // The server now resolves canonical English names to IDs so MantisBT language setting
-    // does not affect how the value is stored.
-    // validate: true ensures Zod defaults are applied before the handler runs.
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 100, summary: 'Test' } }))
-    );
-
-    await mockServer.callTool('create_issue', {
-      summary: 'Test issue',
-      description: 'Test description.',
-      project_id: 1,
-      category: 'General',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.severity).toEqual({ id: 50 });
-  });
-
-  it('returns full issue object when API responds with complete issue', async () => {
-    const fullIssue = { id: 100, summary: 'New issue', status: { id: 10, name: 'new' }, severity: { id: 50, name: 'minor' } };
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: fullIssue }))
-    );
-
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'New issue', description: 'New issue description.', project_id: 1, category: 'General',
-    }, { validate: true });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as typeof fullIssue;
-    expect(parsed.id).toBe(100);
-    expect(parsed.summary).toBe('New issue');
-    // Only one API call — no extra GET needed
-    expect(fetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('fetches full issue via GET when API returns only an id (older MantisBT)', async () => {
-    const fullIssue = { id: 101, summary: 'Created issue', status: { id: 10, name: 'new' } };
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(201, JSON.stringify({ id: 101 })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [fullIssue] })));
-
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Created issue', description: 'Created issue description.', project_id: 1, category: 'General',
-    }, { validate: true });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as typeof fullIssue;
-    expect(parsed.summary).toBe('Created issue');
-    // Two API calls: POST + GET
-    expect(fetch).toHaveBeenCalledTimes(2);
-    const getUrl = vi.mocked(fetch).mock.calls[1]![0] as string;
-    expect(getUrl).toContain('issues/101');
-  });
-
-  it('returns minimal object when GET fallback fails (issue was already created)', async () => {
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(201, JSON.stringify({ id: 102 })))
-      .mockResolvedValueOnce(makeResponse(500, 'Server Error'));
-
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General',
-    }, { validate: true });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { id: number };
-    expect(parsed.id).toBe(102);
-  });
-
-  it('respects an explicitly passed severity', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 101, summary: 'Test' } }))
-    );
-
-    await mockServer.callTool('create_issue', {
-      summary: 'Crash bug',
-      description: 'Crash bug description.',
-      project_id: 1,
-      category: 'General',
-      severity: 'crash',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.severity).toEqual({ id: 70 });
-  });
-
-  it('returns a validation error when description is missing', async () => {
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Test',
-      project_id: 1,
-      category: 'General',
-    }, { validate: true });
-
-    expect(result.isError).toBe(true);
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it('returns a validation error when description is empty', async () => {
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Test',
-      description: '',
-      project_id: 1,
-      category: 'General',
-    }, { validate: true });
-
-    expect(result.isError).toBe(true);
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it('returns an error for an unknown severity name', async () => {
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Test',
-      description: 'Test description.',
-      project_id: 1,
-      category: 'General',
-      severity: 'schwerer Fehler',
-    }, { validate: true });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('schwerer Fehler');
-    expect(result.content[0]!.text).toContain('minor');
-  });
-
-  it('creates issue without any optional fields (backward compatibility)', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 300, summary: 'Minimal' } }))
-    );
-
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Minimal issue',
-      description: 'Minimal description.',
-      project_id: 1,
-      category: 'General',
-    }, { validate: true });
-
-    expect(result.isError).toBeUndefined();
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.version).toBeUndefined();
-    expect(body.target_version).toBeUndefined();
-    expect(body.fixed_in_version).toBeUndefined();
-    expect(body.steps_to_reproduce).toBeUndefined();
-    expect(body.additional_information).toBeUndefined();
-    expect(body.reproducibility).toBeUndefined();
-    expect(body.view_state).toBeUndefined();
-  });
-
-  it('sends version fields as { name } objects', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 301, summary: 'With versions' } }))
-    );
-
-    await mockServer.callTool('create_issue', {
-      summary: 'Version test',
-      description: 'Version test description.',
-      project_id: 1,
-      category: 'General',
-      version: '1.0.0',
-      target_version: '1.1.0',
-      fixed_in_version: '1.0.1',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.version).toEqual({ name: '1.0.0' });
-    expect(body.target_version).toEqual({ name: '1.1.0' });
-    expect(body.fixed_in_version).toEqual({ name: '1.0.1' });
-  });
-
-  it('sends steps_to_reproduce and additional_information as plain strings', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 302, summary: 'With text fields' } }))
-    );
-
-    await mockServer.callTool('create_issue', {
-      summary: 'Text fields test',
-      description: 'Description.',
-      project_id: 1,
-      category: 'General',
-      steps_to_reproduce: '1. Open app\n2. Click button',
-      additional_information: 'Happens only on Windows',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.steps_to_reproduce).toBe('1. Open app\n2. Click button');
-    expect(body.additional_information).toBe('Happens only on Windows');
-  });
-
-  it('resolves reproducibility to { id } via enum lookup', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 303, summary: 'Reproducibility test' } }))
-    );
-
-    await mockServer.callTool('create_issue', {
-      summary: 'Repro test',
-      description: 'Description.',
-      project_id: 1,
-      category: 'General',
-      reproducibility: 'always',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.reproducibility).toEqual({ id: 10 });
-  });
-
-  it('returns error for unknown reproducibility name', async () => {
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Repro test',
-      description: 'Description.',
-      project_id: 1,
-      category: 'General',
-      reproducibility: 'immer',
-    }, { validate: true });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('immer');
-    expect(result.content[0]!.text).toContain('always');
-  });
-
-  it('returns error for empty reproducibility string', async () => {
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Repro test',
-      description: 'Description.',
-      project_id: 1,
-      category: 'General',
-      reproducibility: '',
-    }, { validate: true });
-
-    expect(result.isError).toBe(true);
-  });
-
-  it('sends view_state as { name } object', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 304, summary: 'Private issue' } }))
-    );
-
-    await mockServer.callTool('create_issue', {
-      summary: 'Private issue',
-      description: 'Description.',
-      project_id: 1,
-      category: 'General',
-      view_state: 'private',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.view_state).toEqual({ name: 'private' });
-  });
-
-  it('rejects invalid view_state values', async () => {
-    const result = await mockServer.callTool('create_issue', {
-      summary: 'Test',
-      description: 'Description.',
-      project_id: 1,
-      category: 'General',
-      view_state: 'restricted',
-    }, { validate: true });
-
-    expect(result.isError).toBe(true);
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it('sends all new optional fields together in a single request', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 305, summary: 'Full issue' } }))
-    );
-
-    await mockServer.callTool('create_issue', {
-      summary: 'Full issue',
-      description: 'Full description.',
-      project_id: 1,
-      category: 'General',
-      version: '2.0.0',
-      target_version: '2.1.0',
-      fixed_in_version: '2.0.1',
-      steps_to_reproduce: 'Step 1',
-      additional_information: 'Extra info',
-      reproducibility: 'sometimes',
-      view_state: 'public',
-    }, { validate: true });
-
-    expect(fetch).toHaveBeenCalledTimes(1);
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.version).toEqual({ name: '2.0.0' });
-    expect(body.target_version).toEqual({ name: '2.1.0' });
-    expect(body.fixed_in_version).toEqual({ name: '2.0.1' });
-    expect(body.steps_to_reproduce).toBe('Step 1');
-    expect(body.additional_information).toBe('Extra info');
-    expect(body.reproducibility).toEqual({ id: 30 });
-    expect(body.view_state).toEqual({ name: 'public' });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// create_issue – handler username
-// ---------------------------------------------------------------------------
-
-describe('create_issue – handler username', () => {
-  it('resolves handler username to id from cache and sets handler in body', async () => {
-    const cache = makeStubCache([{ id: 7, name: 'dom' }, { id: 8, name: 'jane' }]);
-    const server = new MockMcpServer();
-    registerIssueTools(server as never, client, cache);
-
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 200, summary: 'New issue', handler: { id: 7, name: 'dom' } } }))
-    );
-
-    await server.callTool('create_issue', {
-      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'dom',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
-    expect(body.handler).toEqual({ id: 7 });
-  });
-
-  it('resolves handler by real_name when name does not match', async () => {
-    const cache = makeStubCache([{ id: 9, name: 'jdoe', real_name: 'John Doe' }]);
-    const server = new MockMcpServer();
-    registerIssueTools(server as never, client, cache);
-
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 201, summary: 'New' } }))
-    );
-
-    await server.callTool('create_issue', {
-      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'John Doe',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
-    expect(body.handler).toEqual({ id: 9 });
-  });
-
-  it('fetches users from API when cache returns null', async () => {
-    const cache = makeStubCache(); // returns null from loadIfValid
-    const server = new MockMcpServer();
-    registerIssueTools(server as never, client, cache);
-
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ users: [{ id: 42, name: 'alice' }] })))
-      .mockResolvedValueOnce(makeResponse(201, JSON.stringify({ issue: { id: 202, summary: 'New' } })));
-
-    await server.callTool('create_issue', {
-      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'alice',
-    }, { validate: true });
-
-    const projectUsersCall = vi.mocked(fetch).mock.calls[0]![0] as string;
-    expect(projectUsersCall).toContain('projects/1/users');
-
-    const createBody = JSON.parse(vi.mocked(fetch).mock.calls[1]![1]!.body as string) as { handler: { id: number } };
-    expect(createBody.handler).toEqual({ id: 42 });
-  });
-
-  it('returns error when handler username is not found', async () => {
-    const cache = makeStubCache([{ id: 7, name: 'dom' }]);
-    const server = new MockMcpServer();
-    registerIssueTools(server as never, client, cache);
-
-    const result = await server.callTool('create_issue', {
-      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'nonexistent',
-    });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('nonexistent');
-    expect(result.content[0]!.text).toContain('dom');
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it('handler_id takes precedence over handler username', async () => {
-    const cache = makeStubCache([{ id: 7, name: 'dom' }]);
-    const server = new MockMcpServer();
-    registerIssueTools(server as never, client, cache);
-
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(201, JSON.stringify({ issue: { id: 203, summary: 'New' } }))
-    );
-
-    await server.callTool('create_issue', {
-      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler_id: 99, handler: 'dom',
-    }, { validate: true });
-
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
-    expect(body.handler).toEqual({ id: 99 });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// list_issues
-// ---------------------------------------------------------------------------
-
-describe('list_issues', () => {
-  it('ist registriert', () => {
-    expect(mockServer.hasToolRegistered('list_issues')).toBe(true);
-  });
-
-  it('gibt Issues-Array zurück', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    const result = await mockServer.callTool('list_issues', { page: 1, page_size: 3 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: unknown[] };
-    expect(Array.isArray(parsed.issues)).toBe(true);
-  });
-
-  it('übergibt project_id als Query-Parameter', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    await mockServer.callTool('list_issues', { project_id: 7, page: 1, page_size: 10 });
-
-    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-    const url = new URL(calledUrl);
-    expect(url.searchParams.get('project_id')).toBe('7');
-  });
-
-  it('passes select as query parameter', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    await mockServer.callTool('list_issues', { select: 'id,summary,status', page: 1, page_size: 10 });
-
-    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-    const url = new URL(calledUrl);
-    expect(url.searchParams.get('select')).toBe('id,summary,status');
-  });
-
-  it('status "open" filters to issues with status.id < 80', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    const result = await mockServer.callTool('list_issues', { status: 'open', page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ status: { id: number } }> };
-    expect(parsed.issues.length).toBeGreaterThan(0);
-    parsed.issues.forEach(issue => {
-      expect(issue.status.id).toBeLessThan(MANTIS_RESOLVED_STATUS_ID);
-    });
-  });
-
-  it('status "resolved" filters to resolved issues only', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    const result = await mockServer.callTool('list_issues', { status: 'resolved', page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ status: { name: string } }> };
-    const resolvedInFixture = listIssuesFixture.issues.filter(i => i.status.name === 'resolved').length;
-    expect(parsed.issues).toHaveLength(resolvedInFixture);
-    parsed.issues.forEach(issue => {
-      expect(issue.status.name).toBe('resolved');
-    });
-  });
-
-  it('status "new" filters to new issues only', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    const result = await mockServer.callTool('list_issues', { status: 'new', page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number; status: { name: string } }> };
-    const newInFixture = listIssuesFixture.issues.filter(i => i.status.name === 'new');
-    expect(parsed.issues).toHaveLength(newInFixture.length);
-    if (newInFixture.length > 0) {
-      expect(parsed.issues[0]!.id).toBe(newInFixture[0]!.id);
-      expect(parsed.issues[0]!.status.name).toBe('new');
-    }
-  });
-
-  it('assigned_to scans multiple API pages (small page_size does not miss results)', async () => {
-    // Regression: previously fetched only page_size items from the API before filtering,
-    // so assigned_to:X with page_size:1 returned 0 results when user's issue was not
-    // in the first page returned by the server.
-    // Now the tool always fetches API_PAGE_SIZE=50 internally when filters are active.
-    const fixtureWithUser51: typeof listIssuesFixture = {
-      ...listIssuesFixture,
-      issues: [
-        // first "slot" has a different user — previously this would have been the only
-        // item fetched with page_size:1, causing a false empty result
-        listIssuesFixture.issues.find(i => (i as { handler?: { id: number } }).handler?.id === 52)!,
-        ...listIssuesFixture.issues.filter(i => (i as { handler?: { id: number } }).handler?.id === 51),
-      ].filter(Boolean),
-    };
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(fixtureWithUser51)));
-
-    const result = await mockServer.callTool('list_issues', { assigned_to: 51, page: 1, page_size: 1 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ handler: { id: number } }> };
-    // Must find results for user 51 despite page_size:1
-    expect(parsed.issues.length).toBeGreaterThan(0);
-    parsed.issues.forEach(issue => expect(issue.handler.id).toBe(51));
-  });
-
-  it('assigned_to filters issues by handler.id (client-side)', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    const result = await mockServer.callTool('list_issues', { assigned_to: 51, page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ handler: { id: number } }> };
-    const expectedCount = listIssuesFixture.issues.filter(i => (i as { handler?: { id: number } }).handler?.id === 51).length;
-    expect(parsed.issues).toHaveLength(expectedCount);
-    parsed.issues.forEach(issue => {
-      expect(issue.handler.id).toBe(51);
-    });
-  });
-
-  it('assigned_to still sends the parameter to the API (server-side hint)', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    await mockServer.callTool('list_issues', { assigned_to: 51, page: 1, page_size: 50 });
-
-    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-    const url = new URL(calledUrl);
-    expect(url.searchParams.get('assigned_to')).toBe('51');
-  });
-
-  it('reporter_id filters issues by reporter.id (client-side)', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-
-    const result = await mockServer.callTool('list_issues', { reporter_id: 52, page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ reporter: { id: number } }> };
-    const expectedCount = listIssuesFixture.issues.filter(i => (i as { reporter?: { id: number } }).reporter?.id === 52).length;
-    expect(parsed.issues).toHaveLength(expectedCount);
-    parsed.issues.forEach(issue => {
-      expect(issue.reporter.id).toBe(52);
-    });
-  });
-
-  it('status filter is case-insensitive', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-    const resultUpper = await mockServer.callTool('list_issues', { status: 'OPEN', page: 1, page_size: 50 });
-
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
-    const resultLower = await mockServer.callTool('list_issues', { status: 'open', page: 1, page_size: 50 });
-
-    const parsedUpper = JSON.parse(resultUpper.content[0]!.text) as { issues: unknown[] };
-    const parsedLower = JSON.parse(resultLower.content[0]!.text) as { issues: unknown[] };
-    expect(parsedUpper.issues.length).toBe(parsedLower.issues.length);
-    expect(parsedUpper.issues).toEqual(parsedLower.issues);
-  });
-
-  it('status canonical name matches by ID even when API returns localized status names', async () => {
-    // Simulate a German MantisBT installation where issue.status.name is localized
-    const localizedFixture = {
-      issues: [
-        { id: 1, status: { id: 10, name: 'Neu' } },
-        { id: 2, status: { id: 80, name: 'Erledigt' } },
-        { id: 3, status: { id: 10, name: 'Neu' } },
-      ],
-      total_count: 3,
-    };
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(localizedFixture)));
-
-    const result = await mockServer.callTool('list_issues', { status: 'new', page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
-    expect(parsed.issues).toHaveLength(2);
-    expect(parsed.issues.map(i => i.id)).toEqual([1, 3]);
-  });
-
-  it('status filter falls back to name comparison for non-canonical values', async () => {
-    // "Neu" is not a canonical status name → falls back to name comparison
-    const localizedFixture = {
-      issues: [
-        { id: 1, status: { id: 10, name: 'Neu' } },
-        { id: 2, status: { id: 80, name: 'Erledigt' } },
-      ],
-      total_count: 2,
-    };
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(localizedFixture)));
-
-    const result = await mockServer.callTool('list_issues', { status: 'Neu', page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
-    expect(parsed.issues).toHaveLength(1);
-    expect(parsed.issues[0]!.id).toBe(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// list_issues – recorded fixtures
-// ---------------------------------------------------------------------------
-
-describe('list_issues – recorded fixtures', () => {
-  it.skipIf(!recordedListIssuesFixture)('status "open" filter matches open issues in recorded fixture', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(recordedListIssuesFixture!)));
-
-    const result = await mockServer.callTool('list_issues', { status: 'open', page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: unknown[] };
-    const openInFixture = recordedListIssuesFixture!.issues.filter(i => i.status.id < 80).length;
-    expect(parsed.issues).toHaveLength(openInFixture);
-  });
-
-  it.skipIf(!recordedListIssuesFixture)('status "resolved" filter matches resolved issues in recorded fixture', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(recordedListIssuesFixture!)));
-
-    const result = await mockServer.callTool('list_issues', { status: 'resolved', page: 1, page_size: 50 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: unknown[] };
-    const resolvedInFixture = recordedListIssuesFixture!.issues.filter(i => i.status.id >= 80).length;
-    expect(parsed.issues).toHaveLength(resolvedInFixture);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// update_issue – fields allowlist
-// ---------------------------------------------------------------------------
-
-describe('update_issue – fields allowlist', () => {
-  it('accepts known string fields (summary, description)', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ issue: { id: 1, summary: 'Updated' } })));
-
-    const result = await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { summary: 'Updated', description: 'New desc' } },
-      { validate: true },
-    );
-
-    expect(result.isError).toBeUndefined();
-  });
-
-  it('accepts known object fields (status, resolution, handler)', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ issue: { id: 1 } })));
-
-    const result = await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { status: { name: 'resolved' }, resolution: { id: 20 }, handler: { id: 5 } } },
-      { validate: true },
-    );
-
-    expect(result.isError).toBeUndefined();
-  });
-
-  it('rejects unknown fields without calling the API', async () => {
-    const result = await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { reporter: { id: 99 } } },
-      { validate: true },
-    );
-
-    expect(result.isError).toBe(true);
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-  });
-
-  it('rejects fields with an unknown key mixed with known keys without calling the API', async () => {
-    const result = await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { summary: 'ok', unknown_field: 'bad' } },
-      { validate: true },
-    );
-
-    expect(result.isError).toBe(true);
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// update_issue – dry_run
-// ---------------------------------------------------------------------------
-
-describe('update_issue – dry_run', () => {
-  it('returns preview payload without calling the API', async () => {
-    const result = await mockServer.callTool(
-      'update_issue',
-      { id: 42, fields: { summary: 'Preview title', status: { name: 'resolved' } }, dry_run: true },
-      { validate: true },
-    );
-
-    expect(result.isError).toBeUndefined();
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-
-    const parsed = JSON.parse(result.content[0]!.text) as { dry_run: boolean; id: number; would_patch: Record<string, unknown> };
-    expect(parsed.dry_run).toBe(true);
-    expect(parsed.id).toBe(42);
-    expect(parsed.would_patch).toEqual({ summary: 'Preview title', status: { name: 'resolved' } });
-  });
-
-  it('defaults to false (normal update) when dry_run is omitted', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ issue: { id: 42, summary: 'Updated' } })));
-
-    const result = await mockServer.callTool(
-      'update_issue',
-      { id: 42, fields: { summary: 'Updated' } },
-      { validate: true },
-    );
-
-    expect(result.isError).toBeUndefined();
-    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
-  });
-
-  it('also rejects unknown fields in dry_run mode without calling the API', async () => {
-    const result = await mockServer.callTool(
-      'update_issue',
-      { id: 42, fields: { unknown_field: 'bad' }, dry_run: true },
-      { validate: true },
-    );
-
-    expect(result.isError).toBe(true);
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// update_issue – enum resolution
-// ---------------------------------------------------------------------------
-
-describe('update_issue – enum resolution', () => {
-  it('resolves canonical severity name to { id } before sending to API', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
-    );
-
-    await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { severity: { name: 'major' } } },
-      { validate: true },
-    );
-
-    // Only one fetch call (the PATCH itself — canonical lookup needs no API call)
-    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.severity).toEqual({ id: 60 }); // major = id 60
-  });
-
-  it('resolves canonical priority name to { id } before sending to API', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
-    );
-
-    await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { priority: { name: 'high' } } },
-      { validate: true },
-    );
-
-    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.priority).toEqual({ id: 40 }); // high = id 40
-  });
-
-  it('resolves canonical status name to { id } before sending to API', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
-    );
-
-    await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { status: { name: 'resolved' } } },
-      { validate: true },
-    );
-
-    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.status).toEqual({ id: 80 }); // resolved = id 80
-  });
-
-  it('does not resolve when id is already provided', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
-    );
-
-    await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { severity: { id: 60 } } },
-      { validate: true },
-    );
-
-    // Only one fetch call — no enum resolution needed
-    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.severity).toEqual({ id: 60 });
-  });
-
-  it('resolves localized enum name to { id } via live enum lookup', async () => {
-    // First fetch: config endpoint for enum data
-    // Second fetch: the actual PATCH
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({
-        configs: [{
-          option: 'severity_enum_string',
-          value: [
-            { id: 50, name: 'Kleiner Fehler' },
-            { id: 60, name: 'Großer Fehler' },
-          ],
-        }],
-      })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issue: { id: 1 } })));
-
-    await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { severity: { name: 'Großer Fehler' } } },
-      { validate: true },
-    );
-
-    // Call 0 = config endpoint, Call 1 = PATCH
-    const patchBody = JSON.parse(vi.mocked(fetch).mock.calls[1]![1]!.body as string) as Record<string, unknown>;
-    expect(patchBody.severity).toEqual({ id: 60 });
-  });
-
-  it('passes unknown enum name through unchanged when resolution fails', async () => {
-    // Config returns no useful data → name stays unchanged
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ configs: [] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issue: { id: 1 } })));
-
-    await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { severity: { name: 'völlig_unbekannt' } } },
-      { validate: true },
-    );
-
-    const patchBody = JSON.parse(vi.mocked(fetch).mock.calls[1]![1]!.body as string) as Record<string, unknown>;
-    expect(patchBody.severity).toEqual({ name: 'völlig_unbekannt' });
-  });
-
-  it('resolves multiple enum fields in one patch call', async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
-    );
-
-    await mockServer.callTool(
-      'update_issue',
-      { id: 1, fields: { status: { name: 'resolved' }, priority: { name: 'high' }, severity: { name: 'major' } } },
-      { validate: true },
-    );
-
-    expect(vi.mocked(fetch)).toHaveBeenCalledOnce(); // all canonical → single PATCH call
-    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.status).toEqual({ id: 80 });
-    expect(body.priority).toEqual({ id: 40 });
-    expect(body.severity).toEqual({ id: 60 });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// list_issues – date filters
-// ---------------------------------------------------------------------------
-
-function makeIssuePage(issues: Array<{ id: number; updated_at: string; created_at: string }>) {
-  return { issues, total_count: issues.length };
-}
-
-describe('list_issues – updated_after filter', () => {
-  it('returns only issues updated after the given date', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
-      { id: 1, updated_at: '2026-03-26T10:00:00Z', created_at: '2026-03-01T00:00:00Z' },
-      { id: 2, updated_at: '2026-03-23T10:00:00Z', created_at: '2026-03-01T00:00:00Z' },
-      { id: 3, updated_at: '2026-03-25T00:00:01Z', created_at: '2026-03-01T00:00:00Z' },
-    ]))));
-
-    const result = await mockServer.callTool('list_issues', {
-      updated_after: '2026-03-25T00:00:00Z',
-    });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
-    expect(parsed.issues.map(i => i.id)).toEqual([1, 3]);
-  });
-
-  it('returns an empty list when no issue matches', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
-      { id: 1, updated_at: '2026-03-20T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
-    ]))));
-
-    const result = await mockServer.callTool('list_issues', {
-      updated_after: '2026-03-25T00:00:00Z',
-    });
-
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<unknown> };
-    expect(parsed.issues).toHaveLength(0);
-  });
-
-  it('stops scanning pages when all issues in a batch are older than updated_after (early-exit)', async () => {
-    // Page 1: one matching issue, one too old
-    // Page 2: should NOT be fetched because the last item of page 1 is already older
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify(makeIssuePage([
-        { id: 10, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
-        { id: 9,  updated_at: '2026-03-20T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
-      ]))))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify(makeIssuePage([
-        { id: 8, updated_at: '2026-03-18T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
-      ]))));
-
-    await mockServer.callTool('list_issues', {
-      updated_after: '2026-03-25T00:00:00Z',
-      page_size: 50,
-    });
-
-    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('list_issues – created_after filter', () => {
-  it('returns only issues created after the given date', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
-      { id: 1, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-26T00:00:00Z' },
-      { id: 2, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-23T00:00:00Z' },
-    ]))));
-
-    const result = await mockServer.callTool('list_issues', {
-      created_after: '2026-03-25T00:00:00Z',
-    });
-
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
-    expect(parsed.issues.map(i => i.id)).toEqual([1]);
-  });
-});
-
-describe('list_issues – combined date window', () => {
-  it('returns only issues within the updated_after + updated_before window', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
-      { id: 1, updated_at: '2026-03-22T00:00:00Z', created_at: '2026-03-01T00:00:00Z' }, // in window
-      { id: 2, updated_at: '2026-03-19T00:00:00Z', created_at: '2026-03-01T00:00:00Z' }, // too old
-      { id: 3, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-01T00:00:00Z' }, // too new
-    ]))));
-
-    const result = await mockServer.callTool('list_issues', {
-      updated_after:  '2026-03-20T00:00:00Z',
-      updated_before: '2026-03-25T00:00:00Z',
-    });
-
-    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
-    expect(parsed.issues.map(i => i.id)).toEqual([1]);
-  });
-});