@projitive/mcp 2.0.3 → 2.1.0

package/output/source/common/store.test.js

@@ -1,26 +1,26 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { ensureStore, getMarkdownViewState, getStoreVersion, loadActionableTasksFromStore, loadRoadmapIdsFromStore, loadRoadmapsFromStore, loadTaskStatusStatsFromStore, loadTasksFromStore, markMarkdownViewBuilt, markMarkdownViewDirty, replaceRoadmapsInStore, replaceTasksInStore, upsertRoadmapInStore, upsertTaskInStore, } from "./store.js";
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureStore, getMarkdownViewState, getStoreVersion, loadActionableTasksFromStore, loadRoadmapIdsFromStore, loadRoadmapsFromStore, loadTaskStatusStatsFromStore, loadTasksFromStore, markMarkdownViewBuilt, markMarkdownViewDirty, replaceRoadmapsInStore, replaceTasksInStore, upsertRoadmapInStore, upsertTaskInStore, } from './store.js';
 const tempPaths = [];
 async function createTempDbPath() {
-    const sandboxRoot = path.join(process.cwd(), ".tmp", "store-tests");
+    const sandboxRoot = path.join(process.cwd(), '.tmp', 'store-tests');
     await fs.mkdir(sandboxRoot, { recursive: true });
-    const dir = await fs.mkdtemp(path.join(sandboxRoot, "case-"));
+    const dir = await fs.mkdtemp(path.join(sandboxRoot, 'case-'));
     tempPaths.push(dir);
-    return path.join(dir, ".projitive");
+    return path.join(dir, '.projitive');
 }
 async function readRawStore(dbPath) {
-    const content = await fs.readFile(dbPath, "utf8");
+    const content = await fs.readFile(dbPath, 'utf8');
     return JSON.parse(content);
 }
 function task(input) {
     return {
         id: input.id,
         title: input.title,
-        status: input.status ?? "TODO",
-        owner: input.owner ?? "",
-        summary: input.summary ?? "",
+        status: input.status ?? 'TODO',
+        owner: input.owner ?? '',
+        summary: input.summary ?? '',
         updatedAt: input.updatedAt ?? new Date().toISOString(),
         links: input.links ?? [],
         roadmapRefs: input.roadmapRefs ?? [],
@@ -32,7 +32,7 @@ function milestone(input) {
     return {
         id: input.id,
         title: input.title,
-        status: input.status ?? "active",
+        status: input.status ?? 'active',
         time: input.time,
         updatedAt: input.updatedAt ?? new Date().toISOString(),
     };
@@ -40,12 +40,12 @@ function milestone(input) {
 afterEach(async () => {
     await Promise.all(tempPaths.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
 });
-describe("store", () => {
-    it("initializes JSON store with default meta/view state", async () => {
+describe('store', () => {
+    it('initializes JSON store with default meta/view state', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         const store = await readRawStore(dbPath);
-        expect(store.schema).toBe("projitive-json-store");
+        expect(store.schema).toBe('projitive-json-store');
         expect(store.meta.store_schema_version).toBe(3);
         expect(store.meta.tasks_version).toBe(0);
         expect(store.meta.roadmaps_version).toBe(0);
@@ -55,65 +55,65 @@ describe("store", () => {
         expect(store.view_state.roadmaps_markdown.lastSourceVersion).toBe(0);
         expect(Array.isArray(store.migration_history)).toBe(true);
     });
-    it("tracks view state dirty/build transitions", async () => {
+    it('tracks view state dirty/build transitions', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
-        const initial = await getMarkdownViewState(dbPath, "tasks_markdown");
+        const initial = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(initial.dirty).toBe(true);
-        await markMarkdownViewBuilt(dbPath, "tasks_markdown", 7, "2026-03-13T00:00:00.000Z");
-        const built = await getMarkdownViewState(dbPath, "tasks_markdown");
+        await markMarkdownViewBuilt(dbPath, 'tasks_markdown', 7, '2026-03-13T00:00:00.000Z');
+        const built = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(built.dirty).toBe(false);
         expect(built.lastSourceVersion).toBe(7);
-        expect(built.lastBuiltAt).toBe("2026-03-13T00:00:00.000Z");
-        await markMarkdownViewDirty(dbPath, "tasks_markdown");
-        const dirtyAgain = await getMarkdownViewState(dbPath, "tasks_markdown");
+        expect(built.lastBuiltAt).toBe('2026-03-13T00:00:00.000Z');
+        await markMarkdownViewDirty(dbPath, 'tasks_markdown');
+        const dirtyAgain = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(dirtyAgain.dirty).toBe(true);
         expect(dirtyAgain.lastSourceVersion).toBe(7);
     });
-    it("upserts tasks and updates source/view versions", async () => {
+    it('upserts tasks and updates source/view versions', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         await upsertTaskInStore(dbPath, task({
-            id: "TASK-0001",
-            title: "First",
-            status: "TODO",
-            owner: "alice",
-            summary: "first",
-            updatedAt: "2026-03-13T00:00:00.000Z",
-            roadmapRefs: ["ROADMAP-0001"],
+            id: 'TASK-0001',
+            title: 'First',
+            status: 'TODO',
+            owner: 'alice',
+            summary: 'first',
+            updatedAt: '2026-03-13T00:00:00.000Z',
+            roadmapRefs: ['ROADMAP-0001'],
         }));
         await upsertTaskInStore(dbPath, task({
-            id: "TASK-0001",
-            title: "First Updated",
-            status: "IN_PROGRESS",
-            owner: "alice",
-            summary: "updated",
-            updatedAt: "2026-03-13T01:00:00.000Z",
-            roadmapRefs: ["ROADMAP-0001"],
-            links: ["reports/r1.md"],
+            id: 'TASK-0001',
+            title: 'First Updated',
+            status: 'IN_PROGRESS',
+            owner: 'alice',
+            summary: 'updated',
+            updatedAt: '2026-03-13T01:00:00.000Z',
+            roadmapRefs: ['ROADMAP-0001'],
+            links: ['reports/r1.md'],
         }));
         const tasks = await loadTasksFromStore(dbPath);
         expect(tasks).toHaveLength(1);
-        expect(tasks[0].title).toBe("First Updated");
-        expect(tasks[0].status).toBe("IN_PROGRESS");
-        expect(tasks[0].links).toEqual(["reports/r1.md"]);
-        const tasksVersion = await getStoreVersion(dbPath, "tasks");
+        expect(tasks[0].title).toBe('First Updated');
+        expect(tasks[0].status).toBe('IN_PROGRESS');
+        expect(tasks[0].links).toEqual(['reports/r1.md']);
+        const tasksVersion = await getStoreVersion(dbPath, 'tasks');
         expect(tasksVersion).toBe(2);
-        const viewState = await getMarkdownViewState(dbPath, "tasks_markdown");
+        const viewState = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(viewState.dirty).toBe(true);
         const store = await readRawStore(dbPath);
-        const updated = store.tasks.find((item) => item.id === "TASK-0001");
+        const updated = store.tasks.find((item) => item.id === 'TASK-0001');
         expect(updated?.recordVersion).toBe(2);
     });
-    it("replaces task set and computes actionable ranking/stats", async () => {
+    it('replaces task set and computes actionable ranking/stats', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         await replaceTasksInStore(dbPath, [
-            task({ id: "TASK-0001", title: "Todo older", status: "TODO", updatedAt: "2026-03-10T00:00:00.000Z" }),
-            task({ id: "TASK-0002", title: "In progress", status: "IN_PROGRESS", updatedAt: "2026-03-12T00:00:00.000Z" }),
-            task({ id: "TASK-0003", title: "Todo newer", status: "TODO", updatedAt: "2026-03-13T00:00:00.000Z" }),
-            task({ id: "TASK-0004", title: "Blocked", status: "BLOCKED", updatedAt: "2026-03-11T00:00:00.000Z" }),
-            task({ id: "TASK-0005", title: "Done", status: "DONE", updatedAt: "2026-03-09T00:00:00.000Z" }),
+            task({ id: 'TASK-0001', title: 'Todo older', status: 'TODO', updatedAt: '2026-03-10T00:00:00.000Z' }),
+            task({ id: 'TASK-0002', title: 'In progress', status: 'IN_PROGRESS', updatedAt: '2026-03-12T00:00:00.000Z' }),
+            task({ id: 'TASK-0003', title: 'Todo newer', status: 'TODO', updatedAt: '2026-03-13T00:00:00.000Z' }),
+            task({ id: 'TASK-0004', title: 'Blocked', status: 'BLOCKED', updatedAt: '2026-03-11T00:00:00.000Z' }),
+            task({ id: 'TASK-0005', title: 'Done', status: 'DONE', updatedAt: '2026-03-09T00:00:00.000Z' }),
         ]);
         const stats = await loadTaskStatusStatsFromStore(dbPath);
         expect(stats.todo).toBe(2);
@@ -121,44 +121,44 @@ describe("store", () => {
         expect(stats.blocked).toBe(1);
         expect(stats.done).toBe(1);
         expect(stats.total).toBe(5);
-        expect(stats.latestUpdatedAt).toBe("2026-03-13T00:00:00.000Z");
+        expect(stats.latestUpdatedAt).toBe('2026-03-13T00:00:00.000Z');
         const actionable = await loadActionableTasksFromStore(dbPath, 2);
         expect(actionable).toHaveLength(2);
-        expect(actionable[0].id).toBe("TASK-0002");
-        expect(actionable[1].id).toBe("TASK-0003");
-        const tasksVersion = await getStoreVersion(dbPath, "tasks");
+        expect(actionable[0].id).toBe('TASK-0002');
+        expect(actionable[1].id).toBe('TASK-0003');
+        const tasksVersion = await getStoreVersion(dbPath, 'tasks');
         expect(tasksVersion).toBe(1);
     });
-    it("upserts/replaces roadmaps and updates versions", async () => {
+    it('upserts/replaces roadmaps and updates versions', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         await upsertRoadmapInStore(dbPath, milestone({
-            id: "ROADMAP-0001",
-            title: "Phase 1",
-            status: "active",
-            updatedAt: "2026-03-10T00:00:00.000Z",
+            id: 'ROADMAP-0001',
+            title: 'Phase 1',
+            status: 'active',
+            updatedAt: '2026-03-10T00:00:00.000Z',
         }));
         await upsertRoadmapInStore(dbPath, milestone({
-            id: "ROADMAP-0001",
-            title: "Phase 1 done",
-            status: "done",
-            time: "2026-Q1",
-            updatedAt: "2026-03-11T00:00:00.000Z",
+            id: 'ROADMAP-0001',
+            title: 'Phase 1 done',
+            status: 'done',
+            time: '2026-Q1',
+            updatedAt: '2026-03-11T00:00:00.000Z',
         }));
         const list1 = await loadRoadmapsFromStore(dbPath);
         expect(list1).toHaveLength(1);
-        expect(list1[0].title).toBe("Phase 1 done");
-        expect(list1[0].status).toBe("done");
-        expect(list1[0].time).toBe("2026-Q1");
+        expect(list1[0].title).toBe('Phase 1 done');
+        expect(list1[0].status).toBe('done');
+        expect(list1[0].time).toBe('2026-Q1');
         await replaceRoadmapsInStore(dbPath, [
-            milestone({ id: "ROADMAP-0002", title: "Phase 2", status: "active", updatedAt: "2026-03-12T00:00:00.000Z" }),
-            milestone({ id: "ROADMAP-0003", title: "Phase 3", status: "done", updatedAt: "2026-03-13T00:00:00.000Z" }),
+            milestone({ id: 'ROADMAP-0002', title: 'Phase 2', status: 'active', updatedAt: '2026-03-12T00:00:00.000Z' }),
+            milestone({ id: 'ROADMAP-0003', title: 'Phase 3', status: 'done', updatedAt: '2026-03-13T00:00:00.000Z' }),
         ]);
         const ids = await loadRoadmapIdsFromStore(dbPath);
-        expect(ids).toEqual(["ROADMAP-0003", "ROADMAP-0002"]);
-        const roadmapsVersion = await getStoreVersion(dbPath, "roadmaps");
+        expect(ids).toEqual(['ROADMAP-0003', 'ROADMAP-0002']);
+        const roadmapsVersion = await getStoreVersion(dbPath, 'roadmaps');
         expect(roadmapsVersion).toBe(3);
-        const viewState = await getMarkdownViewState(dbPath, "roadmaps_markdown");
+        const viewState = await getMarkdownViewState(dbPath, 'roadmaps_markdown');
         expect(viewState.dirty).toBe(true);
     });
 });

package/output/source/common/tool.js

@@ -0,0 +1,43 @@
+import { asText, renderToolResponseMarkdown, renderErrorMarkdown, evidenceSection, guidanceSection, lintSection, nextCallSection, summarySection, } from './response.js';
+export class ToolExecutionError extends Error {
+    nextSteps;
+    retryExample;
+    constructor(message, nextSteps = [], retryExample) {
+        super(message);
+        this.nextSteps = nextSteps;
+        this.retryExample = retryExample;
+        this.name = 'ToolExecutionError';
+    }
+}
+export function createGovernedTool(spec) {
+    const cb = async (input) => {
+        try {
+            const ctx = { now: new Date().toISOString() };
+            const data = await spec.execute(input, ctx);
+            const markdown = renderToolResponseMarkdown({
+                toolName: spec.name,
+                sections: [
+                    summarySection(await spec.summary(data, ctx)),
+                    evidenceSection(await (spec.evidence?.(data, ctx) ?? [])),
+                    guidanceSection(await spec.guidance(data, ctx)),
+                    lintSection(await (spec.suggestions?.(data, ctx) ?? [])),
+                    nextCallSection(await spec.nextCall(data, ctx)),
+                ],
+            });
+            return asText(markdown);
+        }
+        catch (error) {
+            if (error instanceof ToolExecutionError) {
+                return {
+                    ...asText(renderErrorMarkdown(spec.name, error.message, error.nextSteps, error.retryExample)),
+                    isError: true,
+                };
+            }
+            return {
+                ...asText(renderErrorMarkdown(spec.name, String(error), [])),
+                isError: true,
+            };
+        }
+    };
+    return [spec.name, { title: spec.title, description: spec.description, inputSchema: spec.inputSchema }, cb];
+}

package/output/source/common/types.js

@@ -1,7 +1,7 @@
 // Common type definitions (simplified)
 export const VALID_STATUS_TRANSITIONS = {
-    TODO: ["IN_PROGRESS"],
-    IN_PROGRESS: ["TODO", "BLOCKED", "DONE"],
-    BLOCKED: ["IN_PROGRESS"],
+    TODO: ['IN_PROGRESS'],
+    IN_PROGRESS: ['TODO', 'BLOCKED', 'DONE'],
+    BLOCKED: ['IN_PROGRESS'],
     DONE: [],
 };

package/output/source/common/utils.js

@@ -1,29 +1,29 @@
 // Common utility functions
-import fs from "node:fs/promises";
-import path from "node:path";
+import fs from 'node:fs/promises';
+import path from 'node:path';
 /**
  * Safely read Markdown file content, return fallback if file doesn't exist or is empty
  */
 export async function readMarkdownOrFallback(relativePath, fallbackTitle, repoRoot = process.cwd()) {
     const absolutePath = path.resolve(repoRoot, relativePath);
     try {
-        const content = await fs.readFile(absolutePath, "utf-8");
+        const content = await fs.readFile(absolutePath, 'utf-8');
         if (content.trim().length > 0) {
             return content;
         }
     }
     catch (error) {
-        if (error.code !== "ENOENT") {
+        if (!(error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT')) {
             console.error(`Failed to read file: ${absolutePath}`, error);
         }
     }
     return [
         `# ${fallbackTitle}`,
-        "",
+        '',
         `- file: ${relativePath}`,
-        "- status: missing-or-empty",
-        "- next: create this file or ensure it has readable markdown content",
-    ].join("\n");
+        '- status: missing-or-empty',
+        '- next: create this file or ensure it has readable markdown content',
+    ].join('\n');
 }
 /**
  * Capitalize first letter

package/output/source/common/utils.test.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { capitalizeFirstLetter, formatTitle, readMarkdownOrFallback } from './utils.js';
+const tempPaths = [];
+async function createTempDir() {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-utils-test-'));
+    tempPaths.push(dir);
+    return dir;
+}
+afterEach(async () => {
+    vi.restoreAllMocks();
+    await Promise.all(tempPaths.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
+});
+describe('utils module', () => {
+    it('reads markdown content when file exists and is non-empty', async () => {
+        const root = await createTempDir();
+        const filePath = path.join(root, 'README.md');
+        await fs.writeFile(filePath, '# Hello\n', 'utf-8');
+        const content = await readMarkdownOrFallback('README.md', 'Fallback', root);
+        expect(content).toBe('# Hello\n');
+    });
+    it('returns fallback markdown for missing or empty files', async () => {
+        const root = await createTempDir();
+        await fs.writeFile(path.join(root, 'empty.md'), '   ', 'utf-8');
+        const missing = await readMarkdownOrFallback('missing.md', 'Missing Title', root);
+        const empty = await readMarkdownOrFallback('empty.md', 'Empty Title', root);
+        expect(missing).toContain('# Missing Title');
+        expect(missing).toContain('- status: missing-or-empty');
+        expect(empty).toContain('# Empty Title');
+        expect(empty).toContain('- file: empty.md');
+    });
+    it('logs non-ENOENT read errors before falling back', async () => {
+        const root = await createTempDir();
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        vi.spyOn(fs, 'readFile').mockRejectedValueOnce({ code: 'EACCES' });
+        const result = await readMarkdownOrFallback('secret.md', 'Secret', root);
+        expect(result).toContain('# Secret');
+        expect(errorSpy).toHaveBeenCalledOnce();
+    });
+    it('formats title helpers consistently', () => {
+        expect(capitalizeFirstLetter('task_execution')).toBe('TaskExecution');
+        expect(capitalizeFirstLetter('roadmap-next')).toBe('RoadmapNext');
+        expect(formatTitle('task_execution')).toBe('Task Execution');
+        expect(formatTitle('roadmap-next')).toBe('Roadmap Next');
+    });
+});

package/output/source/index.js

@@ -1,36 +1,36 @@
 #!/usr/bin/env node
-import path from "node:path";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import packageJson from "../package.json" with { type: "json" };
-import { registerTools } from "./tools/index.js";
-import { registerPrompts } from "./prompts/index.js";
-import { registerResources } from "./resources/index.js";
-const PROJITIVE_SPEC_VERSION = "1.1.0";
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import packageJson from '../package.json' with { type: 'json' };
+import { registerTools } from './tools/index.js';
+import { registerPrompts } from './prompts/index.js';
+import { registerResources } from './resources/index.js';
+const PROJITIVE_SPEC_VERSION = '1.1.0';
 const currentFilePath = fileURLToPath(import.meta.url);
 const sourceDir = path.dirname(currentFilePath);
-const repoRoot = path.resolve(sourceDir, "..", "..", "..");
-const MCP_RUNTIME_VERSION = typeof packageJson.version === "string" && packageJson.version.trim().length > 0
+const repoRoot = path.resolve(sourceDir, '..', '..', '..');
+const MCP_RUNTIME_VERSION = typeof packageJson.version === 'string' && packageJson.version.trim().length > 0
     ? packageJson.version.trim()
     : PROJITIVE_SPEC_VERSION;
 const server = new McpServer({
-    name: "projitive",
+    name: 'projitive',
     version: MCP_RUNTIME_VERSION,
-    description: "Semantic Projitive MCP for project/task discovery and agent guidance with governance-store-first outputs",
+    description: 'Semantic Projitive MCP for project/task discovery and agent guidance with governance-store-first outputs',
 });
 // 注册所有模块
 registerTools(server);
 registerPrompts(server);
 registerResources(server, repoRoot);
 async function main() {
-    console.error(`[projitive-mcp] starting server`);
+    console.error('[projitive-mcp] starting server');
     console.error(`[projitive-mcp] version=${MCP_RUNTIME_VERSION} spec=${PROJITIVE_SPEC_VERSION} transport=stdio pid=${process.pid}`);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }
 void main().catch((error) => {
-    console.error("Server error:", error);
+    console.error('Server error:', error);
     process.exit(1);
 });

package/output/source/index.runtime.test.js

@@ -0,0 +1,57 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const hoisted = vi.hoisted(() => {
+    const connectMock = vi.fn().mockResolvedValue(undefined);
+    const serverInstance = { connect: connectMock };
+    return {
+        connectMock,
+        serverInstance,
+        registerToolsMock: vi.fn(),
+        registerPromptsMock: vi.fn(),
+        registerResourcesMock: vi.fn(),
+        mcpServerMock: vi.fn().mockImplementation(() => serverInstance),
+        stdioTransportMock: vi.fn().mockImplementation(() => ({ kind: 'stdio' })),
+    };
+});
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
+    McpServer: hoisted.mcpServerMock,
+}));
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+    StdioServerTransport: hoisted.stdioTransportMock,
+}));
+vi.mock('./tools/index.js', () => ({
+    registerTools: hoisted.registerToolsMock,
+}));
+vi.mock('./prompts/index.js', () => ({
+    registerPrompts: hoisted.registerPromptsMock,
+}));
+vi.mock('./resources/index.js', () => ({
+    registerResources: hoisted.registerResourcesMock,
+}));
+describe('index runtime module', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.resetModules();
+        hoisted.connectMock.mockClear();
+        hoisted.registerToolsMock.mockClear();
+        hoisted.registerPromptsMock.mockClear();
+        hoisted.registerResourcesMock.mockClear();
+        hoisted.mcpServerMock.mockClear();
+        hoisted.stdioTransportMock.mockClear();
+    });
+    it('boots the MCP server, registers modules, and connects stdio transport', async () => {
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        await import('./index.js');
+        await Promise.resolve();
+        expect(hoisted.mcpServerMock).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'projitive',
+            description: expect.stringContaining('governance-store-first outputs'),
+        }));
+        expect(hoisted.registerToolsMock).toHaveBeenCalledWith(hoisted.serverInstance);
+        expect(hoisted.registerPromptsMock).toHaveBeenCalledWith(hoisted.serverInstance);
+        expect(hoisted.registerResourcesMock).toHaveBeenCalledWith(hoisted.serverInstance, expect.any(String));
+        expect(hoisted.stdioTransportMock).toHaveBeenCalledOnce();
+        expect(hoisted.connectMock).toHaveBeenCalledOnce();
+        expect(errorSpy).toHaveBeenCalledWith('[projitive-mcp] starting server');
+        expect(errorSpy.mock.calls.some((call) => String(call[0]).includes('transport=stdio'))).toBe(true);
+    });
+});