@aquex/cmos-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,972 @@
+#!/usr/bin/env node
+"use strict";
+// ABOUTME: Main MCP server entry point, including tool dispatch and startup diagnostics.
+// ABOUTME: Runs an attribution self-test at boot so sender-resolution regressions surface immediately.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__test__ = void 0;
+exports.getToolDefinitions = getToolDefinitions;
+exports.summarizeValue = summarizeValue;
+exports.sanitizeArgs = sanitizeArgs;
+exports.buildMissionProtocolContext = buildMissionProtocolContext;
+exports.registerToolHandlers = registerToolHandlers;
+exports.executeMissionProtocolTool = executeMissionProtocolTool;
+exports.runStartupBundledEnvCheck = runStartupBundledEnvCheck;
+/**
+ * Mission Protocol v2 MCP Server
+ *
+ * Main entry point for the MCP server that exposes domain discovery tools.
+ * Uses stdio transport for Claude Desktop integration.
+ *
+ * @module index
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Load .env if present (before any other imports that read process.env).
+// Resolve project root from: env var → directory containing this script.
+// Overrides empty values (present-but-unset is treated as absent) so IDE
+// spawns that pass empty env keys don't shadow .env values.
+const __projectRoot = process.env.CMOS_PROJECT_ROOT ?? path.resolve(__dirname, '..');
+const envPath = path.join(__projectRoot, '.env');
+try {
+    if (fs.existsSync(envPath)) {
+        const lines = fs.readFileSync(envPath, 'utf-8').split('\n');
+        let loaded = 0;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            let value = trimmed.slice(eqIdx + 1).trim();
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            if (!process.env[key]) {
+                process.env[key] = value;
+                loaded++;
+            }
+        }
+        process.stderr.write(`[env-loader] loaded ${loaded} vars from ${envPath}\n`);
+    }
+    else {
+        process.stderr.write(`[env-loader] .env not found at ${envPath}\n`);
+    }
+}
+catch (err) {
+    process.stderr.write(`[env-loader] failed to load ${envPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+}
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const cmos_detector_1 = require("./intelligence/cmos-detector");
+const project_registry_1 = require("./intelligence/project-registry");
+const sender_context_1 = require("./intelligence/sender-context");
+const client_1 = require("./tools/cmos/client");
+const cmos_1 = require("./tools/cmos");
+const token_counters_1 = require("./intelligence/token-counters");
+const tokenizer_bootstrap_1 = require("./intelligence/tokenizer-bootstrap");
+const handler_1 = require("./errors/handler");
+const logger_1 = require("./errors/logger");
+const server_health_1 = require("./server-health");
+const project_key_capture_1 = require("./auth/project-key-capture");
+/**
+ * MCP Server Configuration
+ */
+const SERVER_CONFIG = {
+    name: 'mission-protocol',
+    version: '2.0.0',
+};
+/**
+ * Main server instance
+ */
+const server = new index_js_1.Server({
+    name: SERVER_CONFIG.name,
+    version: SERVER_CONFIG.version,
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const errorLogger = new logger_1.ErrorLogger();
+handler_1.ErrorHandler.useLogger(errorLogger);
+/**
+ * Get tool definitions for the MCP surface.
+ *
+ * @returns Array of CMOS tool definitions
+ */
+function getToolDefinitions() {
+    return [...cmos_1.CMOS_TOOL_DEFINITIONS];
+}
+function summarizeValue(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 5).map((item) => summarizeValue(item));
+    }
+    if (typeof value === 'object') {
+        return '[object]';
+    }
+    if (typeof value === 'string' && value.length > 200) {
+        return `${value.slice(0, 197)}…`;
+    }
+    return value;
+}
+function sanitizeArgs(args) {
+    if (!args || typeof args !== 'object') {
+        return undefined;
+    }
+    const entries = Object.entries(args).slice(0, 10);
+    const sanitized = {};
+    for (const [key, value] of entries) {
+        sanitized[key] = summarizeValue(value);
+    }
+    return sanitized;
+}
+async function buildMissionProtocolContext(options) {
+    const baseDir = options?.baseDir ?? path.resolve(__dirname, '../templates');
+    const defaultModel = options?.defaultModel ?? 'claude';
+    // Initialize token counter for intelligence tools
+    const tokenCounter = new token_counters_1.TokenCounter();
+    // Detect CMOS in the project (respects CMOS_PROJECT_ROOT env var)
+    const projectRoot = (0, cmos_1.resolveProjectRoot)();
+    const detector = cmos_detector_1.CmosDetector.getInstance({ cacheTtlMs: 60000 });
+    const cmosResult = await detector.detect(projectRoot);
+    const cmosDetected = cmosResult.hasCmosDirectory && cmosResult.hasDatabase;
+    return {
+        baseDir,
+        defaultModel,
+        tokenCounter,
+        cmosDetected,
+        cmosDatabasePath: cmosResult.databasePath,
+    };
+}
+let contextBuilder = buildMissionProtocolContext;
+let whoamiCliRunner = runWhoamiCli;
+let startupAttributionSelfTestRunner = runStartupAttributionSelfTest;
+/**
+ * Cached client project roots from MCP roots (all of them, not just the first).
+ * Updated lazily on first CMOS tool call and cleared on `notifications/roots/list_changed`.
+ *
+ * `undefined` means "never probed"; empty array means "probed, none advertised".
+ */
+let cachedClientProjectRoots;
+/**
+ * Get ALL client project roots from MCP roots.
+ *
+ * Sprint 53 m02: changed from `Promise<string | undefined>` (first root only) to
+ * `Promise<string[]>` so `resolveSenderContext` can walk every advertised root and
+ * pick the one that owns a valid `dashboard_project_id`. The former first-only
+ * behavior silently mis-attributed whenever the client advertised multiple roots
+ * in a different order than the operator expected.
+ *
+ * @returns Array of file-system paths. Empty when the client advertises no roots
+ *   or does not support the roots capability.
+ */
+async function getClientProjectRoots() {
+    if (cachedClientProjectRoots !== undefined) {
+        return cachedClientProjectRoots;
+    }
+    const roots = [];
+    try {
+        const rootsResult = await server.listRoots();
+        if (rootsResult.roots && rootsResult.roots.length > 0) {
+            for (const root of rootsResult.roots) {
+                if (root.uri.startsWith('file://')) {
+                    roots.push(decodeURIComponent(root.uri.slice(7)));
+                }
+            }
+            if (roots.length > 0) {
+                console.error(`[INFO] Client project roots from MCP roots: ${roots.join(', ')}`);
+            }
+        }
+    }
+    catch (error) {
+        // Client may not support roots - this is fine, fall back to other methods
+        console.error(`[DEBUG] Could not get client roots: ${error instanceof Error ? error.message : 'unknown'}`);
+    }
+    cachedClientProjectRoots = roots;
+    return cachedClientProjectRoots;
+}
+/**
+ * Fan out a read-only operation across all registered CMOS instances.
+ *
+ * Returns an entry per registered project. Partial failures are included
+ * (not thrown) so callers can surface provenance alongside any errors.
+ *
+ * @param fn - Async service call to run for each projectRoot
+ * @returns Success with per-instance entries, or error if no projects registered
+ */
+async function fanOutRead(fn) {
+    const registry = project_registry_1.ProjectRegistry.getInstance();
+    const projects = await registry.list();
+    if (projects.length === 0) {
+        return {
+            success: false,
+            error: {
+                code: 'CMOS_NOT_DETECTED',
+                message: 'No CMOS projects registered. Cannot fan out without an explicit projectRoot.',
+                suggestion: 'Provide an explicit projectRoot, set CMOS_PROJECT_ROOT, or register a project with cmos_project(action="register").',
+            },
+        };
+    }
+    const entries = await Promise.all(projects.map(async (project) => {
+        const result = await fn(project.projectRoot);
+        return {
+            resolvedFrom: project.projectRoot,
+            success: result.success,
+            data: result.data,
+            error: result.error,
+        };
+    }));
+    return { success: true, data: entries };
+}
+/**
+ * Format fan-out results for LLM consumption.
+ *
+ * Each entry is labelled with its source project and separated by a divider.
+ */
+function formatFanOut(entries, formatEntry) {
+    if (entries.length === 0) {
+        return 'No registered CMOS instances found.';
+    }
+    return entries
+        .map((e) => `[${path.basename(e.resolvedFrom)}] ${e.resolvedFrom}\n${formatEntry(e)}`)
+        .join('\n\n---\n\n');
+}
+/**
+ * Resolve the sender context for a dispatched tool call.
+ *
+ * Sprint 53 m02: replaces the old `resolveCmosProjectRoot` (which silently fell
+ * back to `CMOS_PROJECT_ROOT` env) with the single audited boundary from
+ * `src/intelligence/sender-context.ts`. Every dispatcher case now flows through
+ * this function. `CMOS_PROJECT_ROOT` is no longer consulted at tool dispatch
+ * time — it is retained only for `.env` bootstrap at src/index.ts:17 so the
+ * server can locate its own environment file.
+ *
+ * @param explicitRoot - `params.projectRoot` from the tool call, if any
+ * @param options.requireSenderIdentity - Pass `true` for any call that will hit
+ *   the dashboard with authoritative attribution (today: cmos_message send;
+ *   Sprint 53 m04 adds checkpoint-backfill, registerProject, purge). Defaults to
+ *   `false` for local-DB ops.
+ * @throws SenderResolutionError when no candidate produces an acceptable project.
+ */
+async function resolveToolSenderContext(explicitRoot, options = {}) {
+    const mcpRoots = await getClientProjectRoots();
+    return (0, sender_context_1.resolveSenderContext)({
+        explicitProjectRoot: explicitRoot,
+        mcpRoots,
+        requireSenderIdentity: options.requireSenderIdentity ?? false,
+    });
+}
+/**
+ * Register tool handlers
+ */
+function registerToolHandlers(context, serverInstance) {
+    const targetServer = serverInstance || server;
+    // Listen for roots changes and clear cache
+    targetServer.setNotificationHandler(types_js_1.RootsListChangedNotificationSchema, async () => {
+        console.error(`[INFO] Client roots changed, clearing cache`);
+        cachedClientProjectRoots = undefined;
+    });
+    // List available tools (includes CMOS tools when detected)
+    targetServer.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        return {
+            tools: getToolDefinitions(),
+        };
+    });
+    // Handle tool execution
+    targetServer.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            if (!context) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, 'Server context not initialized');
+            }
+            return await executeMissionProtocolTool(name, args, context);
+        }
+        catch (error) {
+            const sanitizedArgs = sanitizeArgs(args);
+            const data = {
+                tool: name,
+            };
+            if (sanitizedArgs) {
+                data.args = sanitizedArgs;
+            }
+            const missionError = handler_1.ErrorHandler.handle(error, 'server.execute_tool', {
+                module: 'server',
+                data,
+            }, {
+                rethrow: false,
+                userMessage: 'Tool execution failed. Please check inputs and try again.',
+            });
+            const publicError = handler_1.ErrorHandler.toPublicError(missionError);
+            const correlationFragment = publicError.correlationId
+                ? ` (correlationId=${publicError.correlationId})`
+                : '';
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Tool execution failed${correlationFragment}: ${publicError.message}`);
+        }
+    });
+}
+async function executeMissionProtocolTool(name, args, _context) {
+    switch (name) {
+        // ========================================
+        // CMOS Tools (always available, return graceful error if not detected)
+        // ========================================
+        // Consolidated DB admin tool (Sprint 24)
+        case 'cmos_db': {
+            const params = args;
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosDb)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatDbForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated mission CRUD tool (Sprint 24)
+        case 'cmos_mission': {
+            const params = args;
+            if (!params.projectRoot && (0, client_1.isReadAction)('cmos_mission', params.action)) {
+                const fanResult = await fanOutRead((root) => (0, cmos_1.cmosMission)({ ...params, projectRoot: root }));
+                const formatted = fanResult.success
+                    ? formatFanOut(fanResult.data, (e) => (0, cmos_1.formatMissionForLLM)(params.action, {
+                        success: e.success,
+                        data: e.data,
+                        error: e.error,
+                    }))
+                    : String(fanResult.error?.message ?? 'Fan-out failed');
+                return {
+                    content: [{ type: 'text', text: formatted }],
+                    structuredContent: fanResult,
+                    isError: !fanResult.success,
+                };
+            }
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosMission)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatMissionForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated mission transition tool (Sprint 24)
+        case 'cmos_mission_transition': {
+            const params = args;
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosMissionTransition)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatMissionTransitionForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated context tool (Sprint 24)
+        case 'cmos_context': {
+            const params = args;
+            if (!params.projectRoot && (0, client_1.isReadAction)('cmos_context', params.action)) {
+                const fanResult = await fanOutRead((root) => (0, cmos_1.cmosContext)({ ...params, projectRoot: root }));
+                const formatted = fanResult.success
+                    ? formatFanOut(fanResult.data, (e) => (0, cmos_1.formatContextForLLM)(params.action, {
+                        success: e.success,
+                        data: e.data,
+                        error: e.error,
+                    }, params.contextType))
+                    : String(fanResult.error?.message ?? 'Fan-out failed');
+                return {
+                    content: [{ type: 'text', text: formatted }],
+                    structuredContent: fanResult,
+                    isError: !fanResult.success,
+                };
+            }
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosContext)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatContextForLLM)(params.action, result, params.contextType);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated session tool (Sprint 24)
+        case 'cmos_session': {
+            const params = args;
+            if (!params.projectRoot && (0, client_1.isReadAction)('cmos_session', params.action)) {
+                const fanResult = await fanOutRead((root) => (0, cmos_1.cmosSession)({ ...params, projectRoot: root }));
+                const formatted = fanResult.success
+                    ? formatFanOut(fanResult.data, (e) => (0, cmos_1.formatSessionForLLM)(params.action, {
+                        success: e.success,
+                        data: e.data,
+                        error: e.error,
+                    }))
+                    : String(fanResult.error?.message ?? 'Fan-out failed');
+                return {
+                    content: [{ type: 'text', text: formatted }],
+                    structuredContent: fanResult,
+                    isError: !fanResult.success,
+                };
+            }
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosSession)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatSessionForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated decisions tool (Sprint 24)
+        case 'cmos_decisions': {
+            const params = args;
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosDecisions)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatDecisionsForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated learnings tool (Sprint 38)
+        case 'cmos_learnings': {
+            const params = args;
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosLearnings)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatLearningsForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated feedback tool (Sprint 56 m03)
+        case 'cmos_feedback': {
+            const params = args;
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosFeedback)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatFeedbackForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Credential lifecycle (Sprint 57 m03)
+        case 'cmos_auth': {
+            const params = args;
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosAuth)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatAuthForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // At-a-glance status payload (Sprint 62 m06)
+        case 'cmos_status': {
+            const params = args;
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosStatus)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatStatusForLLM)(result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Sprint tools
+        case 'cmos_sprint': {
+            const params = args;
+            if (!params.projectRoot && (0, client_1.isReadAction)('cmos_sprint', params.action)) {
+                const fanResult = await fanOutRead((root) => (0, cmos_1.cmosSprint)({ ...params, projectRoot: root }));
+                const formatted = fanResult.success
+                    ? formatFanOut(fanResult.data, (e) => (0, cmos_1.formatSprintForLLM)(params.action, {
+                        success: e.success,
+                        data: e.data,
+                        error: e.error,
+                    }))
+                    : String(fanResult.error?.message ?? 'Fan-out failed');
+                return {
+                    content: [{ type: 'text', text: formatted }],
+                    structuredContent: fanResult,
+                    isError: !fanResult.success,
+                };
+            }
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosSprint)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatSprintForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        case 'cmos_agent_onboard': {
+            const params = args;
+            const advertisedRoots = await getClientProjectRoots();
+            const callerProvidedProjectRoot = typeof params.projectRoot === 'string';
+            const projectRoot = (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosAgentOnboard)({
+                ...params,
+                projectRoot,
+                advertisedRoots,
+                callerProvidedProjectRoot,
+            });
+            const formatted = (0, cmos_1.formatAgentOnboardForLLM)(result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated message tool (Sprint 28)
+        case 'cmos_message': {
+            const params = args;
+            const advertisedRoots = await getClientProjectRoots();
+            if (params.action === 'whoami') {
+                const result = await (0, cmos_1.getWhoamiDiagnostics)({
+                    explicitProjectRoot: params.projectRoot,
+                    mcpRoots: advertisedRoots,
+                });
+                const formatted = (0, cmos_1.formatMessageForLLM)(params.action, result);
+                return {
+                    content: [{ type: 'text', text: formatted }],
+                    structuredContent: { ...result },
+                    isError: result.success === false,
+                };
+            }
+            // Sprint 53 m02: `send` must resolve through the audited boundary with
+            // `requireSenderIdentity=true`. The former path bypassed root resolution
+            // entirely (see sprint-53-attribution-rebuild.md §Verified Root Cause #2)
+            // and was the structural source of the Stage1→OODS P0. Non-send actions
+            // (list/respond/directory) hit the dashboard directly and don't need a
+            // local project identity, so they skip resolution.
+            let projectRoot = params.projectRoot;
+            if (params.action === 'send') {
+                const ctx = await (0, sender_context_1.resolveSenderContext)({
+                    explicitProjectRoot: params.projectRoot,
+                    mcpRoots: advertisedRoots,
+                    requireSenderIdentity: true,
+                });
+                projectRoot = ctx.projectRoot;
+            }
+            const result = await (0, cmos_1.cmosMessage)({ ...params, projectRoot, advertisedRoots });
+            const formatted = (0, cmos_1.formatMessageForLLM)(params.action, result);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        // Consolidated project tool (Sprint 24)
+        case 'cmos_project': {
+            const params = args;
+            // init/register take a literal user-supplied path (destination for a new
+            // workspace, or path to register). Routing through resolveToolSenderContext
+            // would fall back to the caller's own project when the path has no CMOS DB,
+            // which for init clobbers the caller's metadata with a fresh seed. The
+            // action handlers validate the path themselves and reject empty/missing input.
+            const isLiteralPathAction = params.action === 'init' || params.action === 'register';
+            const projectRoot = isLiteralPathAction
+                ? params.projectRoot
+                : (await resolveToolSenderContext(params.projectRoot)).projectRoot;
+            const result = await (0, cmos_1.cmosProject)({ ...params, projectRoot });
+            const formatted = (0, cmos_1.formatProjectForLLM)(params.action, result, {
+                validate: params.validate,
+            });
+            return {
+                content: [{ type: 'text', text: formatted }],
+                structuredContent: { ...result },
+                isError: result.success === false,
+            };
+        }
+        default:
+            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+    }
+}
+async function runWhoamiCli() {
+    const result = await (0, cmos_1.getWhoamiDiagnostics)();
+    console.log((0, cmos_1.formatMessageForLLM)('whoami', result));
+    return result.success ? 0 : 1;
+}
+/**
+ * Walk the registry, drop entries whose `projectRoot` no longer contains a
+ * CMOS database, and emit a concise log line so the operator can see drift.
+ *
+ * Sprint 56 m01: registry pollution was blowing the fanout response cap on
+ * read surfaces. Auto-prune at boot keeps the registry bounded by live
+ * projects without requiring a manual `cmos_project(action="validate")`.
+ */
+async function runStartupRegistryPrune() {
+    try {
+        const registry = await project_registry_1.ProjectRegistry.create();
+        const before = (await registry.list()).length;
+        const pruned = await registry.prune();
+        const remaining = (await registry.list()).length;
+        return { totalBefore: before, pruned, remaining, error: null };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'unknown error';
+        return { totalBefore: null, pruned: 0, remaining: null, error: message };
+    }
+}
+let startupRegistryPruneRunner = runStartupRegistryPrune;
+// Sprint 57 m02: startup recovery for partial-failure auto-issue. Non-fatal.
+let startupProjectKeyRecoveryRunner = project_key_capture_1.runStartupProjectKeyRecovery;
+// Sprint 58 m02: startup credential-store empty-check. Non-fatal.
+let startupCredentialCheckRunner = project_key_capture_1.runStartupCredentialCheck;
+function runStartupBundledEnvCheck(serverInstallRoot = sender_context_1.SERVER_INSTALL_ROOT) {
+    const installedFromNpm = serverInstallRoot.includes(`${path.sep}node_modules${path.sep}`);
+    if (!installedFromNpm) {
+        return { installedFromNpm: false, envFilePath: null, envFileBundled: false };
+    }
+    const envFilePath = path.join(serverInstallRoot, '.env');
+    const envFileBundled = fs.existsSync(envFilePath);
+    return { installedFromNpm: true, envFilePath, envFileBundled };
+}
+let startupBundledEnvCheckRunner = runStartupBundledEnvCheck;
+async function runStartupAttributionSelfTest() {
+    try {
+        const resolved = await (0, sender_context_1.resolveSenderContext)({
+            requireSenderIdentity: true,
+        });
+        return {
+            projectRoot: resolved.projectRoot,
+            source: resolved.source,
+            errorCode: null,
+            warning: resolved.projectRoot === sender_context_1.SERVER_INSTALL_ROOT
+                ? 'SERVER_INSTALL_ROOT resolved as the sender. Remediation: run the server from the client project or rely on advertised MCP roots.'
+                : null,
+        };
+    }
+    catch (error) {
+        if (error instanceof sender_context_1.SenderResolutionError) {
+            const installRootGuardCandidate = error.candidates.find((candidate) => candidate.source === 'cwd' &&
+                candidate.projectRoot === sender_context_1.SERVER_INSTALL_ROOT &&
+                candidate.rejectReason?.includes('cwd-vs-SERVER_INSTALL_ROOT guard'));
+            return {
+                projectRoot: null,
+                source: null,
+                errorCode: error.code,
+                warning: installRootGuardCandidate
+                    ? 'SERVER_INSTALL_ROOT would have been the implicit sender. Remediation: run the server from the client project or rely on advertised MCP roots.'
+                    : null,
+            };
+        }
+        const message = error instanceof Error ? error.message : 'unknown error';
+        return {
+            projectRoot: null,
+            source: null,
+            errorCode: 'SELF_TEST_FAILED',
+            warning: `Startup attribution self-test failed unexpectedly: ${message}`,
+        };
+    }
+}
+/**
+ * Initialize server components
+ */
+async function initializeServer() {
+    try {
+        console.error(`[INFO] Initializing MCP server...`);
+        const context = await contextBuilder();
+        console.error(`[INFO] Template base directory: ${context.baseDir}`);
+        console.error(`[INFO] Default intelligence model: ${context.defaultModel}`);
+        // Sprint 53 m02 / m04: startup diagnostic for attribution. `SERVER_INSTALL_ROOT`
+        // is the one path that must never be the *implicit* sender for another project;
+        // operators see it here so they can verify before debugging misrouted sends.
+        const envProjectRoot = process.env[cmos_1.CMOS_PROJECT_ROOT_ENV];
+        console.error(`[INFO] Server install root: ${sender_context_1.SERVER_INSTALL_ROOT}`);
+        console.error(`[INFO] Sender attribution diagnostics: Server install root: ${sender_context_1.SERVER_INSTALL_ROOT}. ` +
+            `${cmos_1.CMOS_PROJECT_ROOT_ENV} env: ${envProjectRoot ?? 'unset'}. Roots support: probed on first call.`);
+        if (envProjectRoot) {
+            console.error(`[WARN] ${cmos_1.CMOS_PROJECT_ROOT_ENV}=${envProjectRoot} is set. Sprint 53 removed this from the ` +
+                `tool-dispatch resolution chain — it is retained only for .env bootstrap. If you relied on ` +
+                `this env to pin attribution, pass projectRoot explicitly or ensure your MCP client advertises ` +
+                `roots. Every outbound send will fail-closed rather than silently attribute to the server's ` +
+                `own project.`);
+        }
+        else {
+            console.error(`[INFO] ${cmos_1.CMOS_PROJECT_ROOT_ENV} env: unset (expected post-Sprint-53).`);
+        }
+        const registryPrune = await startupRegistryPruneRunner();
+        if (registryPrune.error) {
+            console.error(`[WARN] Registry prune skipped: ${registryPrune.error} — continuing startup with unpruned registry.`);
+        }
+        else if (registryPrune.pruned > 0) {
+            console.error(`[INFO] pruned ${registryPrune.pruned} stale entries from project registry (${registryPrune.remaining} remaining)`);
+        }
+        else {
+            console.error(`[INFO] Project registry healthy: ${registryPrune.remaining ?? 0} entries, no stale entries pruned`);
+        }
+        const attributionSelfTest = await startupAttributionSelfTestRunner();
+        if (attributionSelfTest.projectRoot && attributionSelfTest.source) {
+            console.error(`[INFO] Sender attribution self-test: ${attributionSelfTest.source} -> ${attributionSelfTest.projectRoot}`);
+        }
+        else {
+            console.error(`[INFO] Sender attribution self-test: unresolved (${attributionSelfTest.errorCode ?? 'unknown'})`);
+        }
+        if (attributionSelfTest.warning) {
+            console.error(`[P0] Sender attribution self-test warning: ${attributionSelfTest.warning}`);
+        }
+        // Sprint 57 m02: partial-failure recovery for projects registered on the
+        // dashboard but with no local project key. Non-fatal — startup continues
+        // regardless of the outcome.
+        try {
+            const recoveryRoot = attributionSelfTest.projectRoot ?? undefined;
+            const recovery = await startupProjectKeyRecoveryRunner({
+                ...(recoveryRoot ? { projectRoot: recoveryRoot } : {}),
+            });
+            if (recovery.status === 'recovered') {
+                console.error(`[INFO] Project key recovery: ${recovery.message}`);
+            }
+            else if (recovery.status === 'error') {
+                console.error(`[WARN] Project key recovery: ${recovery.message}`);
+            }
+            else {
+                console.error(`[INFO] Project key recovery: ${recovery.status} — ${recovery.message}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'unknown error';
+            console.error(`[WARN] Project key recovery hook threw (non-fatal): ${message}. Continuing startup.`);
+        }
+        // Sprint 58 m02: surface an empty credential store with a one-line
+        // [WARN] pointing at cmos_auth(action="login"). Makes the "just nothing
+        // happens" first-run state audible. Non-fatal.
+        try {
+            await startupCredentialCheckRunner();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'unknown error';
+            console.error(`[WARN] Startup credential check threw (non-fatal): ${message}. Continuing startup.`);
+        }
+        // Sprint 62 m02: detect a .env file accidentally bundled inside the npm
+        // package — protects against accidental credential leaks to the registry.
+        // Non-fatal; only fires when running from a node_modules install.
+        try {
+            const bundledEnv = startupBundledEnvCheckRunner();
+            if (bundledEnv.envFileBundled && bundledEnv.envFilePath) {
+                console.error(`[WARN] cmos-mcp: a .env file was found inside the installed package at ${bundledEnv.envFilePath}. ` +
+                    `This may contain credentials that should not have been published. ` +
+                    `Inspect the file, treat any contained secrets as compromised, and report the issue at ` +
+                    `https://github.com/kneelinghorse/cmos-mcp/issues. The server will continue running.`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'unknown error';
+            console.error(`[WARN] Startup bundled-env check threw (non-fatal): ${message}. Continuing startup.`);
+        }
+        await (0, tokenizer_bootstrap_1.ensureTokenizersReady)();
+        const tokenizerHealth = (0, tokenizer_bootstrap_1.getTokenizerHealth)();
+        console.error(`[INFO] Tokenizer preload status: GPT ready=${tokenizerHealth.models.gpt.ready} (attempts=${tokenizerHealth.models.gpt.attempts}), ` +
+            `Claude ready=${tokenizerHealth.models.claude.ready} (attempts=${tokenizerHealth.models.claude.attempts}), ` +
+            `fallbacks=${JSON.stringify(tokenizerHealth.fallbacks)}`);
+        // Initialize server health tracking (build staleness detection)
+        (0, server_health_1.initServerHealth)();
+        const serverHealth = (0, server_health_1.getServerHealth)();
+        console.error(`[INFO] Server health: pid=${serverHealth.pid} build=${serverHealth.startupBuild?.buildHash.slice(0, 12) ?? 'none'}…`);
+        console.error(`[INFO] Server components initialized successfully`);
+        return context;
+    }
+    catch (error) {
+        const missionError = handler_1.ErrorHandler.handle(error, 'server.initialize', {
+            module: 'server',
+        }, {
+            rethrow: false,
+            userMessage: 'Failed to initialize Mission Protocol server components.',
+        });
+        throw missionError;
+    }
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    try {
+        if (process.argv.includes('--whoami')) {
+            const exitCode = await whoamiCliRunner();
+            if (exitCode !== 0) {
+                process.exit(exitCode);
+            }
+            return;
+        }
+        // Initialize all server components
+        const context = await initializeServer();
+        // Register tool handlers
+        registerToolHandlers(context);
+        // Create stdio transport
+        const transport = new stdio_js_1.StdioServerTransport();
+        // Connect server to transport
+        await server.connect(transport);
+        console.error(`[INFO] Mission Protocol MCP server running on stdio`);
+        console.error(`[INFO] Server: ${SERVER_CONFIG.name} v${SERVER_CONFIG.version}`);
+        const totalTools = getToolDefinitions().length;
+        console.error(`[INFO] ${totalTools} tools registered`);
+        if (context.cmosDetected) {
+            console.error(`[INFO] CMOS detected, ${cmos_1.CMOS_TOOL_DEFINITIONS.length} CMOS tools enabled`);
+            console.error(`[INFO] CMOS database: ${context.cmosDatabasePath}`);
+        }
+    }
+    catch (error) {
+        const missionError = handler_1.ErrorHandler.handle(error, 'server.startup', {
+            module: 'server',
+            data: {
+                stage: 'startup',
+            },
+        }, {
+            rethrow: false,
+            userMessage: 'Mission Protocol server startup failed.',
+        });
+        const publicError = handler_1.ErrorHandler.toPublicError(missionError);
+        const correlationFragment = publicError.correlationId
+            ? ` (correlationId=${publicError.correlationId})`
+            : '';
+        console.error(`[FATAL] Server startup failed${correlationFragment}: ${publicError.message}`);
+        process.exit(1);
+    }
+}
+exports.__test__ = {
+    registerToolHandlers,
+    initializeServer,
+    main,
+    runWhoamiCli,
+    server,
+    setContextBuilder: (builder) => {
+        contextBuilder = builder;
+    },
+    resetContextBuilder: () => {
+        contextBuilder = buildMissionProtocolContext;
+    },
+    setWhoamiCliRunner: (runner) => {
+        whoamiCliRunner = runner;
+    },
+    resetWhoamiCliRunner: () => {
+        whoamiCliRunner = runWhoamiCli;
+    },
+    setStartupAttributionSelfTestRunner: (runner) => {
+        startupAttributionSelfTestRunner = runner;
+    },
+    resetStartupAttributionSelfTestRunner: () => {
+        startupAttributionSelfTestRunner = runStartupAttributionSelfTest;
+    },
+    runStartupRegistryPrune,
+    setStartupRegistryPruneRunner: (runner) => {
+        startupRegistryPruneRunner = runner;
+    },
+    resetStartupRegistryPruneRunner: () => {
+        startupRegistryPruneRunner = runStartupRegistryPrune;
+    },
+    setStartupProjectKeyRecoveryRunner: (runner) => {
+        startupProjectKeyRecoveryRunner = runner;
+    },
+    resetStartupProjectKeyRecoveryRunner: () => {
+        startupProjectKeyRecoveryRunner = project_key_capture_1.runStartupProjectKeyRecovery;
+    },
+    setStartupCredentialCheckRunner: (runner) => {
+        startupCredentialCheckRunner = runner;
+    },
+    resetStartupCredentialCheckRunner: () => {
+        startupCredentialCheckRunner = project_key_capture_1.runStartupCredentialCheck;
+    },
+    runStartupBundledEnvCheck,
+    setStartupBundledEnvCheckRunner: (runner) => {
+        startupBundledEnvCheckRunner = runner;
+    },
+    resetStartupBundledEnvCheckRunner: () => {
+        startupBundledEnvCheckRunner = runStartupBundledEnvCheck;
+    },
+};
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+    console.error(`[INFO] Received SIGINT, shutting down gracefully...`);
+    try {
+        await server.close();
+    }
+    catch (error) {
+        handler_1.ErrorHandler.handle(error, 'server.shutdown', {
+            module: 'server',
+            data: {
+                signal: 'SIGINT',
+            },
+        }, {
+            rethrow: false,
+            userMessage: 'Graceful shutdown encountered an issue.',
+        });
+    }
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    console.error(`[INFO] Received SIGTERM, shutting down gracefully...`);
+    try {
+        await server.close();
+    }
+    catch (error) {
+        handler_1.ErrorHandler.handle(error, 'server.shutdown', {
+            module: 'server',
+            data: {
+                signal: 'SIGTERM',
+            },
+        }, {
+            rethrow: false,
+            userMessage: 'Graceful shutdown encountered an issue.',
+        });
+    }
+    process.exit(0);
+});
+// Start the server
+if (require.main === module) {
+    main().catch((error) => {
+        const missionError = handler_1.ErrorHandler.handle(error, 'server.unhandled', {
+            module: 'server',
+        }, {
+            rethrow: false,
+            userMessage: 'Mission Protocol encountered an unrecoverable error.',
+        });
+        const publicError = handler_1.ErrorHandler.toPublicError(missionError);
+        const correlationFragment = publicError.correlationId
+            ? ` (correlationId=${publicError.correlationId})`
+            : '';
+        console.error(`[FATAL] Unhandled error${correlationFragment}: ${publicError.message}`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=index.js.map