devchain-cli 0.1.0

package/dist/server/modules/mcp/services/mcp.service.js

@@ -0,0 +1,2056 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpService = void 0;
+const common_1 = require("@nestjs/common");
+const storage_interface_1 = require("../../storage/interfaces/storage.interface");
+const chat_service_1 = require("../../chat/services/chat.service");
+const sessions_service_1 = require("../../sessions/services/sessions.service");
+const terminal_gateway_1 = require("../../terminal/gateways/terminal.gateway");
+const epics_service_1 = require("../../epics/services/epics.service");
+const logger_1 = require("../../../common/logging/logger");
+const path_1 = require("path");
+const mcp_dto_1 = require("../dtos/mcp.dto");
+const instructions_resolver_1 = require("./instructions-resolver");
+const error_types_1 = require("../../../common/errors/error-types");
+const common_2 = require("@nestjs/common");
+const zod_1 = require("zod");
+const logger = (0, logger_1.createLogger)('McpService');
+let McpService = class McpService {
+    constructor(storage, chatService, sessionsService, terminalGateway, epicsService) {
+        this.storage = storage;
+        this.chatService = chatService;
+        this.sessionsService = sessionsService;
+        this.terminalGateway = terminalGateway;
+        this.epicsService = epicsService;
+        this.DEFAULT_INLINE_MAX_BYTES = 64 * 1024;
+        logger.info('McpService initialized');
+        this.featureFlags = this.storage.getFeatureFlags();
+        this.instructionsResolver = new instructions_resolver_1.InstructionsResolver(this.storage, (document, cache, maxDepth, maxBytes) => this.buildInlineResolution(document, cache, maxDepth, maxBytes), this.featureFlags);
+    }
+    async resolveAgentByNameUnique(projectId, name) {
+        const normalized = name.trim().toLowerCase();
+        const list = await this.storage.listAgents(projectId, { limit: 1000, offset: 0 });
+        const matches = list.items.filter((a) => a.name.toLowerCase() === normalized);
+        if (matches.length === 0) {
+            return {
+                success: false,
+                error: {
+                    code: 'AGENT_NOT_FOUND',
+                    message: `Agent "${name}" not found in project`,
+                    data: { availableNames: list.items.map((a) => a.name) },
+                },
+            };
+        }
+        if (matches.length > 1) {
+            return {
+                success: false,
+                error: {
+                    code: 'AMBIGUOUS_AGENT_NAME',
+                    message: `Multiple agents named "${name}" found in project; please disambiguate`,
+                    data: { matches: matches.map((a) => ({ id: a.id, name: a.name })) },
+                },
+            };
+        }
+        return { id: matches[0].id, name: matches[0].name };
+    }
+    validateAbsolutePath(pathValue) {
+        if (!pathValue) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PATH',
+                    message: 'Path parameter is required and cannot be empty.',
+                },
+            };
+        }
+        if (!(0, path_1.isAbsolute)(pathValue)) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PATH',
+                    message: 'Path must be an absolute filesystem path. Please provide the full project root path (e.g., /home/user/project).',
+                },
+            };
+        }
+        return null;
+    }
+    async resolveProject(pathValue) {
+        const pathValidation = this.validateAbsolutePath(pathValue);
+        if (pathValidation) {
+            return { error: pathValidation };
+        }
+        const project = await this.storage.findProjectByPath(pathValue);
+        if (!project) {
+            logger.debug('No project found for provided path');
+            return {
+                error: {
+                    success: false,
+                    error: {
+                        code: 'PROJECT_NOT_FOUND',
+                        message: 'No project found for provided path',
+                    },
+                },
+            };
+        }
+        logger.debug({ projectId: project.id }, 'Resolved path to project');
+        return { project };
+    }
+    async handleToolCall(tool, params) {
+        try {
+            const normalizedTool = tool.replace(/[.\-/]/g, '_');
+            logger.info({ tool: normalizedTool, originalTool: tool, params }, 'Handling MCP tool call');
+            switch (normalizedTool) {
+                case 'devchain_create_record':
+                    return await this.createRecord(params);
+                case 'devchain_update_record':
+                    return await this.updateRecord(params);
+                case 'devchain_get_record':
+                    return await this.getRecord(params);
+                case 'devchain_list_records':
+                    return await this.listRecords(params);
+                case 'devchain_add_tags':
+                    return await this.addTags(params);
+                case 'devchain_remove_tags':
+                    return await this.removeTags(params);
+                case 'devchain_list_documents':
+                    return await this.listDocuments(params);
+                case 'devchain_get_document':
+                    return await this.getDocument(params);
+                case 'devchain_create_document':
+                    return await this.createDocument(params);
+                case 'devchain_update_document':
+                    return await this.updateDocument(params);
+                case 'devchain_list_prompts':
+                    return await this.listPrompts(params);
+                case 'devchain_get_prompt':
+                    return await this.getPrompt(params);
+                case 'devchain_list_agents':
+                    return await this.listAgents(params);
+                case 'devchain_get_agent_by_name':
+                    return await this.getAgentByName(params);
+                case 'devchain_list_statuses':
+                    return await this.listStatuses(params);
+                case 'devchain_list_epics':
+                    return await this.listEpics(params);
+                case 'devchain_list_assigned_epics_tasks':
+                    return await this.listAssignedEpicsTasks(params);
+                case 'devchain_create_epic':
+                    return await this.createEpic(params);
+                case 'devchain_get_epic_by_id':
+                    return await this.getEpicById(params);
+                case 'devchain_add_epic_comment':
+                    return await this.addEpicComment(params);
+                case 'devchain_update_epic':
+                    return await this.updateEpic(params);
+                case 'notifications_initialized':
+                    return { success: true, data: { acknowledged: true } };
+                case 'devchain_send_message':
+                    return await this.sendMessage(params);
+                case 'devchain_chat_ack':
+                    return await this.chatAck(params);
+                case 'devchain_chat_list_members':
+                    return await this.chatListMembers(params);
+                case 'devchain_chat_read_history':
+                    return await this.chatReadHistory(params);
+                case 'devchain_activity_start':
+                    return await this.activityStart(params);
+                case 'devchain_activity_finish':
+                    return await this.activityFinish(params);
+                default:
+                    logger.warn({ tool: normalizedTool }, 'Unknown MCP tool');
+                    return {
+                        success: false,
+                        error: {
+                            code: 'UNKNOWN_TOOL',
+                            message: `Unknown tool: ${tool}`,
+                        },
+                    };
+            }
+        }
+        catch (error) {
+            logger.error({ tool, error }, 'MCP tool call failed');
+            if (error instanceof zod_1.ZodError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'VALIDATION_ERROR',
+                        message: 'Invalid parameters supplied to MCP tool.',
+                        data: { issues: error.issues },
+                    },
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    code: 'INTERNAL_ERROR',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                },
+            };
+        }
+    }
+    async handleResourceRequest(uri) {
+        try {
+            logger.info({ uri }, 'Handling MCP resource request');
+            if (uri.startsWith('doc://')) {
+                return await this.resolveDocumentResource(uri);
+            }
+            if (uri.startsWith('prompt://')) {
+                return await this.resolvePromptResource(uri);
+            }
+            return {
+                success: false,
+                error: {
+                    code: 'UNKNOWN_RESOURCE',
+                    message: `Unknown resource: ${uri}`,
+                },
+            };
+        }
+        catch (error) {
+            logger.error({ uri, error }, 'MCP resource handler failed');
+            return {
+                success: false,
+                error: {
+                    code: 'INTERNAL_ERROR',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                },
+            };
+        }
+    }
+    async createRecord(params) {
+        const validated = mcp_dto_1.CreateRecordParamsSchema.parse(params);
+        const record = await this.storage.createRecord({
+            epicId: validated.epicId,
+            type: validated.type,
+            data: validated.data,
+            tags: validated.tags || [],
+        });
+        const response = {
+            id: record.id,
+            epicId: record.epicId,
+            type: record.type,
+            data: record.data,
+            tags: record.tags,
+            version: record.version,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+        return { success: true, data: response };
+    }
+    async updateRecord(params) {
+        const validated = mcp_dto_1.UpdateRecordParamsSchema.parse(params);
+        const record = await this.storage.updateRecord(validated.id, {
+            data: validated.data,
+            type: validated.type,
+            tags: validated.tags,
+        }, validated.version);
+        const response = {
+            id: record.id,
+            epicId: record.epicId,
+            type: record.type,
+            data: record.data,
+            tags: record.tags,
+            version: record.version,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+        return { success: true, data: response };
+    }
+    async getRecord(params) {
+        const validated = mcp_dto_1.GetRecordParamsSchema.parse(params);
+        const record = await this.storage.getRecord(validated.id);
+        const response = {
+            id: record.id,
+            epicId: record.epicId,
+            type: record.type,
+            data: record.data,
+            tags: record.tags,
+            version: record.version,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+        return { success: true, data: response };
+    }
+    async listRecords(params) {
+        const validated = mcp_dto_1.ListRecordsParamsSchema.parse(params);
+        const result = await this.storage.listRecords(validated.epicId, {
+            limit: validated.limit,
+            offset: validated.offset,
+        });
+        let filtered = result.items;
+        if (validated.type) {
+            filtered = filtered.filter((r) => r.type === validated.type);
+        }
+        if (validated.tags && validated.tags.length > 0) {
+            filtered = filtered.filter((r) => {
+                return validated.tags.every((tag) => r.tags.includes(tag));
+            });
+        }
+        const response = {
+            records: filtered.map((r) => ({
+                id: r.id,
+                epicId: r.epicId,
+                type: r.type,
+                data: r.data,
+                tags: r.tags,
+                version: r.version,
+                createdAt: r.createdAt,
+                updatedAt: r.updatedAt,
+            })),
+            total: filtered.length,
+        };
+        return { success: true, data: response };
+    }
+    async addTags(params) {
+        const validated = mcp_dto_1.AddTagsParamsSchema.parse(params);
+        const record = await this.storage.getRecord(validated.id);
+        const newTags = Array.from(new Set([...record.tags, ...validated.tags]));
+        const updated = await this.storage.updateRecord(validated.id, { tags: newTags }, record.version);
+        const response = {
+            id: updated.id,
+            tags: updated.tags,
+        };
+        return { success: true, data: response };
+    }
+    async removeTags(params) {
+        const validated = mcp_dto_1.RemoveTagsParamsSchema.parse(params);
+        const record = await this.storage.getRecord(validated.id);
+        const newTags = record.tags.filter((tag) => !validated.tags.includes(tag));
+        const updated = await this.storage.updateRecord(validated.id, { tags: newTags }, record.version);
+        const response = {
+            id: updated.id,
+            tags: updated.tags,
+        };
+        return { success: true, data: response };
+    }
+    async listDocuments(params) {
+        const validated = mcp_dto_1.ListDocumentsParamsSchema.parse(params);
+        const pathValidation = this.validateAbsolutePath(validated.path);
+        if (pathValidation) {
+            return pathValidation;
+        }
+        const project = await this.storage.findProjectByPath(validated.path);
+        if (!project) {
+            logger.debug({ path: validated.path }, 'No project found for path, returning empty results');
+            return {
+                success: true,
+                data: {
+                    documents: [],
+                    total: 0,
+                    limit: validated.limit ?? 100,
+                    offset: validated.offset ?? 0,
+                },
+            };
+        }
+        logger.debug({ path: validated.path, projectId: project.id }, 'Resolved path to project');
+        const filters = {
+            projectId: project.id,
+        };
+        if (validated.tags?.length) {
+            filters.tags = validated.tags;
+        }
+        if (validated.q) {
+            filters.q = validated.q;
+        }
+        if (validated.limit !== undefined) {
+            filters.limit = validated.limit;
+        }
+        if (validated.offset !== undefined) {
+            filters.offset = validated.offset;
+        }
+        const result = await this.storage.listDocuments(filters);
+        const response = {
+            documents: result.items.map((doc) => this.mapDocumentSummary(doc)),
+            total: result.total,
+            limit: result.limit,
+            offset: result.offset,
+        };
+        return { success: true, data: response };
+    }
+    async getDocument(params) {
+        const validated = mcp_dto_1.GetDocumentParamsSchema.parse(params);
+        const includeLinks = validated.includeLinks ?? 'meta';
+        let document;
+        if (validated.id) {
+            document = await this.storage.getDocument({ id: validated.id });
+        }
+        else {
+            const projectId = validated.projectId === '' ? null : validated.projectId;
+            document = await this.storage.getDocument({ slug: validated.slug, projectId });
+        }
+        const response = {
+            document: this.mapDocumentDetail(document),
+            links: [],
+        };
+        let cache = new Map();
+        if (includeLinks !== 'none') {
+            const collected = await this.collectDocumentLinks(document);
+            response.links = collected.links;
+            cache = collected.cache;
+            if (includeLinks === 'inline') {
+                const inline = await this.buildInlineResolution(document, cache, validated.maxDepth ?? 1, validated.maxBytes ?? this.DEFAULT_INLINE_MAX_BYTES);
+                response.resolved = inline;
+            }
+        }
+        return { success: true, data: response };
+    }
+    async createDocument(params) {
+        const validated = mcp_dto_1.CreateDocumentParamsSchema.parse(params);
+        const pathValidation = this.validateAbsolutePath(validated.path);
+        if (pathValidation) {
+            return pathValidation;
+        }
+        const project = await this.storage.findProjectByPath(validated.path);
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: `No project found for path: ${validated.path}`,
+                },
+            };
+        }
+        logger.debug({ path: validated.path, projectId: project.id }, 'Resolved path to project for document creation');
+        const document = await this.storage.createDocument({
+            projectId: project.id,
+            title: validated.title,
+            contentMd: validated.contentMd,
+            tags: validated.tags,
+        });
+        const response = {
+            document: this.mapDocumentDetail(document),
+        };
+        return { success: true, data: response };
+    }
+    async updateDocument(params) {
+        const validated = mcp_dto_1.UpdateDocumentParamsSchema.parse(params);
+        const document = await this.storage.updateDocument(validated.id, {
+            title: validated.title,
+            slug: validated.slug,
+            contentMd: validated.contentMd,
+            tags: validated.tags,
+            archived: validated.archived,
+            version: validated.version,
+        });
+        const response = {
+            document: this.mapDocumentDetail(document),
+        };
+        return { success: true, data: response };
+    }
+    async listPrompts(params) {
+        const validated = mcp_dto_1.ListPromptsParamsSchema.parse(params);
+        let projectId;
+        if (validated.path) {
+            const pathCheck = this.validateAbsolutePath(validated.path);
+            if (pathCheck) {
+                return pathCheck;
+            }
+            const project = await this.storage.findProjectByPath(validated.path);
+            if (!project) {
+                logger.debug({ path: validated.path }, 'No project found for path; returning empty prompts');
+                return { success: true, data: { prompts: [], total: 0 } };
+            }
+            projectId = project.id;
+        }
+        else if (validated.projectId) {
+            projectId = validated.projectId;
+            logger.warn('ListPrompts called with deprecated projectId parameter; prefer path');
+        }
+        else {
+            return {
+                success: false,
+                error: { code: 'INVALID_PARAMS', message: 'path is required for devchain_list_prompts' },
+            };
+        }
+        const result = await this.storage.listPrompts(projectId ?? null, undefined);
+        let items = result.items;
+        if (validated.tags?.length) {
+            items = items.filter((prompt) => validated.tags.every((tag) => prompt.tags.includes(tag)));
+        }
+        if (validated.q) {
+            const query = validated.q.toLowerCase();
+            items = items.filter((prompt) => prompt.title.toLowerCase().includes(query) ||
+                prompt.content.toLowerCase().includes(query));
+        }
+        const response = {
+            prompts: items.map((prompt) => this.mapPromptSummary(prompt)),
+            total: items.length,
+        };
+        return { success: true, data: response };
+    }
+    async getPrompt(params) {
+        const validated = mcp_dto_1.GetPromptParamsSchema.parse(params);
+        let prompt;
+        if (validated.id) {
+            prompt = await this.storage.getPrompt(validated.id);
+        }
+        else if (validated.name) {
+            let projectId;
+            if (validated.path) {
+                const pathCheck = this.validateAbsolutePath(validated.path);
+                if (pathCheck)
+                    return pathCheck;
+                const project = await this.storage.findProjectByPath(validated.path);
+                if (!project) {
+                    return {
+                        success: false,
+                        error: { code: 'PROJECT_NOT_FOUND', message: 'No project found for provided path' },
+                    };
+                }
+                projectId = project.id;
+            }
+            else if (validated.projectId) {
+                projectId = validated.projectId;
+                logger.warn('GetPrompt called with deprecated projectId parameter; prefer path');
+            }
+            else {
+                return {
+                    success: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'path is required when querying prompt by name',
+                    },
+                };
+            }
+            const list = await this.storage.listPrompts(projectId ?? null, undefined);
+            prompt = list.items.find((item) => {
+                if (item.title !== validated.name) {
+                    return false;
+                }
+                if (validated.version !== undefined) {
+                    return item.version === validated.version;
+                }
+                return true;
+            });
+            if (prompt) {
+                prompt = await this.storage.getPrompt(prompt.id);
+            }
+        }
+        if (!prompt) {
+            throw new Error('Prompt not found');
+        }
+        const response = {
+            prompt: this.mapPromptSummary(prompt),
+        };
+        return { success: true, data: response };
+    }
+    async listAgents(params) {
+        const validated = mcp_dto_1.ListAgentsParamsSchema.parse(params);
+        const pathValidation = this.validateAbsolutePath(validated.path);
+        if (pathValidation) {
+            return pathValidation;
+        }
+        const project = await this.storage.findProjectByPath(validated.path);
+        if (!project) {
+            logger.debug({ path: validated.path }, 'No project found for path, returning empty agent list');
+            return {
+                success: true,
+                data: {
+                    agents: [],
+                    total: 0,
+                    limit: validated.limit ?? 100,
+                    offset: validated.offset ?? 0,
+                },
+            };
+        }
+        const limit = validated.limit ?? 100;
+        const offset = validated.offset ?? 0;
+        const normalizedQuery = validated.q?.toLowerCase();
+        const fetchOptions = normalizedQuery ? { limit: limit + offset, offset: 0 } : { limit, offset };
+        const result = await this.storage.listAgents(project.id, fetchOptions);
+        let agents = result.items;
+        if (normalizedQuery) {
+            agents = agents.filter((agent) => agent.name.toLowerCase().includes(normalizedQuery));
+        }
+        const paginatedAgents = normalizedQuery ? agents.slice(offset, offset + limit) : agents;
+        const response = {
+            agents: paginatedAgents.map((agent) => ({
+                id: agent.id,
+                name: agent.name,
+                profileId: agent.profileId,
+            })),
+            total: normalizedQuery ? agents.length : result.total,
+            limit,
+            offset,
+        };
+        return { success: true, data: response };
+    }
+    async getAgentByName(params) {
+        const validated = mcp_dto_1.GetAgentByNameParamsSchema.parse(params);
+        const pathValidation = this.validateAbsolutePath(validated.path);
+        if (pathValidation) {
+            return pathValidation;
+        }
+        const project = await this.storage.findProjectByPath(validated.path);
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: `No project found for path: ${validated.path}`,
+                },
+            };
+        }
+        const normalizedName = validated.name.trim().toLowerCase();
+        const agentsList = await this.storage.listAgents(project.id, { limit: 1000, offset: 0 });
+        const candidate = agentsList.items.find((agent) => agent.name.toLowerCase() === normalizedName);
+        if (!candidate) {
+            return {
+                success: false,
+                error: {
+                    code: 'AGENT_NOT_FOUND',
+                    message: `Agent "${validated.name}" not found in project`,
+                    data: {
+                        availableNames: agentsList.items.map((agent) => agent.name),
+                    },
+                },
+            };
+        }
+        let agentWithProfile;
+        try {
+            agentWithProfile = await this.storage.getAgentByName(project.id, candidate.name);
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'AGENT_NOT_FOUND',
+                        message: `Agent "${validated.name}" not found in project`,
+                        data: {
+                            availableNames: agentsList.items.map((agent) => agent.name),
+                        },
+                    },
+                };
+            }
+            logger.warn({ projectId: project.id, name: candidate.name, error }, 'Agent lookup failed after matching by name');
+            throw error;
+        }
+        const profile = agentWithProfile.profile;
+        const resolvedInstructions = profile
+            ? await this.instructionsResolver.resolve(project.id, profile.instructions ?? null, {
+                maxBytes: this.DEFAULT_INLINE_MAX_BYTES,
+            })
+            : null;
+        if (profile && this.featureFlags.enableProfileInstructionTemplates) {
+        }
+        const response = {
+            agent: {
+                id: agentWithProfile.id,
+                name: agentWithProfile.name,
+                profileId: agentWithProfile.profileId,
+                profile: profile
+                    ? {
+                        id: profile.id,
+                        name: profile.name,
+                        instructions: profile.instructions ?? null,
+                        instructionsResolved: resolvedInstructions ?? undefined,
+                    }
+                    : undefined,
+            },
+        };
+        return { success: true, data: response };
+    }
+    async listStatuses(params) {
+        const validated = mcp_dto_1.ListStatusesParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const result = await this.storage.listStatuses(resolution.project.id, {
+            limit: 1000,
+            offset: 0,
+        });
+        const response = {
+            statuses: result.items.map((status) => this.mapStatusSummary(status)),
+        };
+        return { success: true, data: response };
+    }
+    async listEpics(params) {
+        const validated = mcp_dto_1.ListEpicsParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const project = resolution.project;
+        let statusId;
+        if (validated.statusName) {
+            const status = await this.storage.findStatusByName(project.id, validated.statusName);
+            if (!status) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'STATUS_NOT_FOUND',
+                        message: `Status "${validated.statusName}" was not found for project ${project.id}.`,
+                    },
+                };
+            }
+            statusId = status.id;
+        }
+        const limit = validated.limit ?? 100;
+        const offset = validated.offset ?? 0;
+        const query = validated.q?.trim();
+        const result = await this.storage.listProjectEpics(project.id, {
+            statusId,
+            q: query && query.length ? query : undefined,
+            limit,
+            offset,
+        });
+        const statusesResult = await this.storage.listStatuses(project.id, {
+            limit: 1000,
+            offset: 0,
+        });
+        const statusById = new Map();
+        for (const s of statusesResult.items)
+            statusById.set(s.id, s);
+        const agentIds = new Set();
+        for (const epic of result.items) {
+            if (epic.agentId)
+                agentIds.add(epic.agentId);
+        }
+        const agentNameById = new Map();
+        for (const agentId of agentIds) {
+            try {
+                const agent = await this.storage.getAgent(agentId);
+                agentNameById.set(agentId, agent.name);
+            }
+            catch (error) {
+                logger.warn({ agentId }, 'Failed to resolve agent name');
+            }
+        }
+        const epicsWithStatus = result.items.map((epic) => {
+            const summary = this.mapEpicSummary(epic, agentNameById);
+            const s = statusById.get(epic.statusId);
+            if (s) {
+                summary.status = this.mapStatusSummary(s);
+            }
+            return summary;
+        });
+        const response = {
+            epics: epicsWithStatus,
+            total: result.total,
+            limit: result.limit,
+            offset: result.offset,
+        };
+        return { success: true, data: response };
+    }
+    async listAssignedEpicsTasks(params) {
+        const validated = mcp_dto_1.ListAssignedEpicsTasksParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const project = resolution.project;
+        const limit = validated.limit ?? 100;
+        const offset = validated.offset ?? 0;
+        try {
+            const result = await this.storage.listAssignedEpics(project.id, {
+                agentName: validated.agentName,
+                limit,
+                offset,
+            });
+            const statusesResult = await this.storage.listStatuses(project.id, {
+                limit: 1000,
+                offset: 0,
+            });
+            const statusById = new Map();
+            for (const s of statusesResult.items)
+                statusById.set(s.id, s);
+            const agentIds = new Set();
+            for (const epic of result.items) {
+                if (epic.agentId)
+                    agentIds.add(epic.agentId);
+            }
+            const agentNameById = new Map();
+            for (const agentId of agentIds) {
+                try {
+                    const agent = await this.storage.getAgent(agentId);
+                    agentNameById.set(agentId, agent.name);
+                }
+                catch (error) {
+                    logger.warn({ agentId }, 'Failed to resolve agent name');
+                }
+            }
+            const epicsWithStatus = result.items.map((epic) => {
+                const summary = this.mapEpicSummary(epic, agentNameById);
+                const s = statusById.get(epic.statusId);
+                if (s) {
+                    summary.status = this.mapStatusSummary(s);
+                }
+                return summary;
+            });
+            const response = {
+                epics: epicsWithStatus,
+                total: result.total,
+                limit: result.limit,
+                offset: result.offset,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'AGENT_NOT_FOUND',
+                        message: `Agent "${validated.agentName}" was not found for project ${project.id}.`,
+                    },
+                };
+            }
+            if (error instanceof error_types_1.ValidationError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'VALIDATION_ERROR',
+                        message: error.message,
+                        data: error.details,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async createEpic(params) {
+        if (!this.epicsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'Epic creation requires full app context (not available in standalone MCP mode)',
+                },
+            };
+        }
+        const validated = mcp_dto_1.CreateEpicParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const project = resolution.project;
+        let statusId;
+        if (validated.statusName) {
+            const status = await this.storage.findStatusByName(project.id, validated.statusName);
+            if (!status) {
+                const statusesResult = await this.storage.listStatuses(project.id, {
+                    limit: 1000,
+                    offset: 0,
+                });
+                return {
+                    success: false,
+                    error: {
+                        code: 'STATUS_NOT_FOUND',
+                        message: `Status "${validated.statusName}" was not found for project.`,
+                        data: {
+                            availableStatuses: statusesResult.items.map((s) => ({ id: s.id, name: s.label })),
+                        },
+                    },
+                };
+            }
+            statusId = status.id;
+        }
+        try {
+            const epic = await this.epicsService.createEpicForProject(project.id, {
+                title: validated.title,
+                description: validated.description ?? null,
+                statusId,
+                tags: validated.tags ?? [],
+                agentName: validated.agentName,
+                parentId: validated.parentId ?? null,
+            });
+            let agentNameById;
+            if (epic.agentId) {
+                agentNameById = new Map();
+                try {
+                    const agent = await this.storage.getAgent(epic.agentId);
+                    agentNameById.set(epic.agentId, agent.name);
+                }
+                catch (error) {
+                    logger.warn({ agentId: epic.agentId }, 'Failed to resolve agent name');
+                }
+            }
+            const response = {
+                epic: this.mapEpicSummary(epic, agentNameById),
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'AGENT_NOT_FOUND',
+                        message: `Agent "${validated.agentName}" was not found for project ${project.id}.`,
+                    },
+                };
+            }
+            if (error instanceof error_types_1.ValidationError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'VALIDATION_ERROR',
+                        message: error.message,
+                        data: error.details,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async getEpicById(params) {
+        const validated = mcp_dto_1.GetEpicByIdParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const project = resolution.project;
+        let epic;
+        try {
+            epic = await this.storage.getEpic(validated.id);
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'EPIC_NOT_FOUND',
+                        message: `Epic ${validated.id} was not found.`,
+                    },
+                };
+            }
+            throw error;
+        }
+        if (epic.projectId !== project.id) {
+            return {
+                success: false,
+                error: {
+                    code: 'EPIC_NOT_FOUND',
+                    message: `Epic ${validated.id} does not belong to the resolved project.`,
+                },
+            };
+        }
+        const commentsResult = await this.storage.listEpicComments(epic.id, {
+            limit: 250,
+            offset: 0,
+        });
+        const subEpicsResult = await this.storage.listSubEpics(epic.id, { limit: 250, offset: 0 });
+        const statusesResult = await this.storage.listStatuses(project.id, {
+            limit: 1000,
+            offset: 0,
+        });
+        const statusById = new Map();
+        for (const s of statusesResult.items)
+            statusById.set(s.id, s);
+        const agentIds = new Set();
+        if (epic.agentId)
+            agentIds.add(epic.agentId);
+        for (const child of subEpicsResult.items) {
+            if (child.agentId)
+                agentIds.add(child.agentId);
+        }
+        const agentNameById = new Map();
+        for (const agentId of agentIds) {
+            try {
+                const agent = await this.storage.getAgent(agentId);
+                agentNameById.set(agentId, agent.name);
+            }
+            catch (error) {
+                logger.warn({ agentId }, 'Failed to resolve agent name');
+            }
+        }
+        let parentSummary;
+        if (epic.parentId) {
+            try {
+                const parent = await this.storage.getEpic(epic.parentId);
+                if (parent.projectId === project.id) {
+                    parentSummary = this.mapEpicParent(parent);
+                }
+            }
+            catch (error) {
+                if (error instanceof error_types_1.NotFoundError) {
+                    logger.warn({ epicId: epic.id, parentId: epic.parentId }, 'Parent epic missing');
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        const epicSummary = this.mapEpicSummary(epic, agentNameById);
+        const epicStatus = statusById.get(epic.statusId);
+        if (epicStatus) {
+            epicSummary.status = this.mapStatusSummary(epicStatus);
+        }
+        const subEpicsWithStatus = subEpicsResult.items.map((child) => {
+            const childSummary = this.mapEpicChild(child);
+            const childStatus = statusById.get(child.statusId);
+            if (childStatus) {
+                childSummary.status = this.mapStatusSummary(childStatus);
+            }
+            return childSummary;
+        });
+        const response = {
+            epic: epicSummary,
+            comments: [...commentsResult.items]
+                .reverse()
+                .map((comment, idx) => ({ ...this.mapEpicComment(comment), commentNumber: idx + 1 })),
+            subEpics: subEpicsWithStatus,
+        };
+        if (parentSummary) {
+            response.parent = parentSummary;
+        }
+        return { success: true, data: response };
+    }
+    async addEpicComment(params) {
+        const validated = mcp_dto_1.AddEpicCommentParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const project = resolution.project;
+        let epic;
+        try {
+            epic = await this.storage.getEpic(validated.epicId);
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'EPIC_NOT_FOUND',
+                        message: `Epic ${validated.epicId} was not found.`,
+                    },
+                };
+            }
+            throw error;
+        }
+        if (epic.projectId !== project.id) {
+            return {
+                success: false,
+                error: {
+                    code: 'EPIC_NOT_FOUND',
+                    message: `Epic ${validated.epicId} does not belong to the resolved project.`,
+                },
+            };
+        }
+        const comment = await this.storage.createEpicComment({
+            epicId: validated.epicId,
+            authorName: validated.authorName,
+            content: validated.content,
+        });
+        const response = {
+            comment: this.mapEpicComment(comment),
+        };
+        return { success: true, data: response };
+    }
+    async updateEpic(params) {
+        if (!this.epicsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'Epic updates require full app context (not available in standalone MCP mode)',
+                },
+            };
+        }
+        let preprocessedParams = params;
+        if (params && typeof params === 'object' && 'assignment' in params) {
+            const p = params;
+            if (typeof p.assignment === 'string') {
+                try {
+                    preprocessedParams = { ...p, assignment: JSON.parse(p.assignment) };
+                }
+                catch {
+                }
+            }
+        }
+        const validated = mcp_dto_1.UpdateEpicParamsSchema.parse(preprocessedParams);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const project = resolution.project;
+        let epic;
+        try {
+            epic = await this.storage.getEpic(validated.id);
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'EPIC_NOT_FOUND',
+                        message: `Epic ${validated.id} was not found.`,
+                    },
+                };
+            }
+            throw error;
+        }
+        if (epic.projectId !== project.id) {
+            return {
+                success: false,
+                error: {
+                    code: 'EPIC_NOT_FOUND',
+                    message: `Epic ${validated.id} does not belong to the resolved project.`,
+                },
+            };
+        }
+        const updateData = {};
+        if (validated.title !== undefined) {
+            updateData.title = validated.title;
+        }
+        if (validated.description !== undefined) {
+            updateData.description = validated.description;
+        }
+        if (validated.statusName) {
+            const status = await this.storage.findStatusByName(project.id, validated.statusName);
+            if (!status) {
+                const statusesResult = await this.storage.listStatuses(project.id, {
+                    limit: 1000,
+                    offset: 0,
+                });
+                return {
+                    success: false,
+                    error: {
+                        code: 'STATUS_NOT_FOUND',
+                        message: `Status "${validated.statusName}" was not found for project.`,
+                        data: {
+                            availableStatuses: statusesResult.items.map((s) => ({ id: s.id, name: s.label })),
+                        },
+                    },
+                };
+            }
+            updateData.statusId = status.id;
+        }
+        if (validated.assignment) {
+            if ('clear' in validated.assignment && validated.assignment.clear) {
+                updateData.agentId = null;
+            }
+            else if ('agentName' in validated.assignment) {
+                try {
+                    const agent = await this.storage.getAgentByName(project.id, validated.assignment.agentName);
+                    updateData.agentId = agent.id;
+                }
+                catch (error) {
+                    if (error instanceof error_types_1.NotFoundError) {
+                        const agentsList = await this.storage.listAgents(project.id, {
+                            limit: 1000,
+                            offset: 0,
+                        });
+                        return {
+                            success: false,
+                            error: {
+                                code: 'AGENT_NOT_FOUND',
+                                message: `Agent "${validated.assignment.agentName}" was not found for project.`,
+                                data: {
+                                    availableAgents: agentsList.items.map((a) => ({ id: a.id, name: a.name })),
+                                },
+                            },
+                        };
+                    }
+                    throw error;
+                }
+            }
+        }
+        if (validated.clearParent) {
+            updateData.parentId = null;
+        }
+        else if (validated.parentId !== undefined) {
+            if (validated.parentId === validated.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'PARENT_INVALID',
+                        message: 'An epic cannot be its own parent.',
+                    },
+                };
+            }
+            let parentEpic;
+            try {
+                parentEpic = await this.storage.getEpic(validated.parentId);
+            }
+            catch (error) {
+                if (error instanceof error_types_1.NotFoundError) {
+                    return {
+                        success: false,
+                        error: {
+                            code: 'PARENT_INVALID',
+                            message: `Parent epic ${validated.parentId} was not found.`,
+                        },
+                    };
+                }
+                throw error;
+            }
+            if (parentEpic.projectId !== project.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'PARENT_INVALID',
+                        message: 'Parent epic must belong to the same project.',
+                    },
+                };
+            }
+            if (parentEpic.parentId !== null) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'HIERARCHY_CONFLICT',
+                        message: 'Only one level of epic hierarchy is allowed. The specified parent already has a parent.',
+                    },
+                };
+            }
+            updateData.parentId = validated.parentId;
+        }
+        if (validated.setTags !== undefined) {
+            updateData.tags = validated.setTags;
+        }
+        else if (validated.addTags || validated.removeTags) {
+            const currentTags = new Set(epic.tags);
+            if (validated.addTags) {
+                validated.addTags.forEach((tag) => currentTags.add(tag));
+            }
+            if (validated.removeTags) {
+                validated.removeTags.forEach((tag) => currentTags.delete(tag));
+            }
+            updateData.tags = Array.from(currentTags);
+        }
+        let updatedEpic;
+        try {
+            updatedEpic = await this.epicsService.updateEpic(validated.id, updateData, validated.version);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('was modified by another operation')) {
+                const currentEpic = await this.storage.getEpic(validated.id);
+                return {
+                    success: false,
+                    error: {
+                        code: 'VERSION_CONFLICT',
+                        message: `Epic version conflict. Expected version ${validated.version}, but current version is ${currentEpic.version}.`,
+                        data: {
+                            currentVersion: currentEpic.version,
+                        },
+                    },
+                };
+            }
+            throw error;
+        }
+        let agentNameById;
+        if (updatedEpic.agentId) {
+            agentNameById = new Map();
+            try {
+                const agent = await this.storage.getAgent(updatedEpic.agentId);
+                agentNameById.set(updatedEpic.agentId, agent.name);
+            }
+            catch (error) {
+                logger.warn({ agentId: updatedEpic.agentId }, 'Failed to resolve agent name');
+            }
+        }
+        const response = {
+            epic: this.mapEpicSummary(updatedEpic, agentNameById),
+        };
+        return { success: true, data: response };
+    }
+    async sendMessage(params) {
+        if (!this.chatService || !this.sessionsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'Chat functionality requires full app context (not available in standalone MCP mode)',
+                },
+            };
+        }
+        const validated = mcp_dto_1.SendMessageParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project) {
+            return resolution.error;
+        }
+        const project = resolution.project;
+        try {
+            let senderAgentId = null;
+            const validatedWithRecipient = validated;
+            const recipientType = validatedWithRecipient.recipient ?? 'agents';
+            const senderNameInput = validated.senderName ?? validatedWithRecipient.agentName;
+            if (senderNameInput) {
+                const resolved = await this.resolveAgentByNameUnique(project.id, senderNameInput);
+                if (!('id' in resolved)) {
+                    return resolved;
+                }
+                senderAgentId = resolved.id;
+            }
+            let normalizedRecipientIds = [];
+            if (validated.recipientAgentNames && validated.recipientAgentNames.length > 0) {
+                for (const name of validated.recipientAgentNames) {
+                    const agent = await this.storage.getAgentByName(project.id, name);
+                    normalizedRecipientIds.push(agent.id);
+                }
+            }
+            normalizedRecipientIds = Array.from(new Set(normalizedRecipientIds.filter((id) => id && id !== senderAgentId)));
+            let threadId = validated.threadId;
+            if (!threadId && senderAgentId) {
+                if (recipientType === 'user') {
+                    const direct = await this.chatService.createDirectThread({
+                        projectId: project.id,
+                        agentId: senderAgentId,
+                    });
+                    threadId = direct.id;
+                }
+                else {
+                    const recips = normalizedRecipientIds;
+                    if (recips.length === 0) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'RECIPIENTS_REQUIRED',
+                                message: 'Recipient agents must be provided when creating a new thread without threadId.',
+                            },
+                        };
+                    }
+                    const groupThread = await this.chatService.createGroupThread({
+                        projectId: project.id,
+                        agentIds: Array.from(new Set([senderAgentId, ...recips])),
+                        createdByType: 'agent',
+                        createdByAgentId: senderAgentId,
+                    });
+                    threadId = groupThread.id;
+                }
+            }
+            if (!threadId) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'THREAD_REQUIRED',
+                        message: 'threadId is required when senderName is not provided',
+                    },
+                };
+            }
+            const thread = await this.chatService.getThread(threadId);
+            const message = await this.chatService.createMessage(threadId, {
+                authorType: senderAgentId ? 'agent' : 'user',
+                authorAgentId: senderAgentId ?? undefined,
+                content: validated.message,
+            });
+            let targetAgentIds = normalizedRecipientIds;
+            if (senderAgentId &&
+                thread.members &&
+                thread.members.length > 1 &&
+                targetAgentIds.length === 0) {
+                targetAgentIds = thread.members.filter((id) => id !== senderAgentId);
+            }
+            const activeSessions = await this.sessionsService.listActiveSessions();
+            const delivered = [];
+            for (const agentId of targetAgentIds) {
+                const agent = await this.storage.getAgent(agentId);
+                const session = activeSessions.find((s) => s.agentId === agentId);
+                if (session) {
+                    const senderName = senderAgentId
+                        ? (await this.storage.getAgent(senderAgentId)).name
+                        : 'User';
+                    const injectionText = `\n[CHAT] From: ${senderName} • Thread: ${threadId}\n${validated.message}\n[ACK] tools/call { name: "devchain_chat_ack", arguments: { thread_id: "${threadId}", message_id: "${message.id}", agent_name: "${agent.name}" } }\n`;
+                    await this.sessionsService.injectTextIntoSession(session.id, injectionText);
+                    delivered.push({
+                        agentId,
+                        agentName: agent.name,
+                        sessionId: session.id,
+                        status: 'delivered',
+                    });
+                }
+                else {
+                    delivered.push({
+                        agentId,
+                        agentName: agent.name,
+                        sessionId: '',
+                        status: 'queued',
+                    });
+                }
+            }
+            const response = {
+                threadId,
+                messageId: message.id,
+                deliveryCount: delivered.filter((d) => d.status === 'delivered').length,
+                delivered,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            logger.error({ error, params: validated }, 'sendMessage failed');
+            return {
+                success: false,
+                error: {
+                    code: 'SEND_MESSAGE_FAILED',
+                    message: error instanceof Error ? error.message : 'Failed to send message',
+                },
+            };
+        }
+    }
+    async chatAck(params) {
+        if (!this.chatService || !this.terminalGateway) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'Chat acknowledgment requires full app context (not available in standalone MCP mode)',
+                },
+            };
+        }
+        const validated = mcp_dto_1.ChatAckParamsSchema.parse(params);
+        const { thread_id: threadId, message_id: messageId } = validated;
+        let agentId = null;
+        try {
+            const thread = await this.chatService.getThread(threadId);
+            const memberIds = thread.members ?? [];
+            let resolved = null;
+            for (const mid of memberIds) {
+                const a = await this.storage.getAgent(mid);
+                if (a.name.toLowerCase() === validated.agent_name.toLowerCase()) {
+                    resolved = a.id;
+                    break;
+                }
+            }
+            if (!resolved) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'AGENT_NOT_IN_THREAD',
+                        message: `Agent ${validated.agent_name} is not a member of thread ${threadId}`,
+                    },
+                };
+            }
+            agentId = resolved;
+            const now = new Date().toISOString();
+            await this.storage.markMessageAsRead(messageId, agentId, now);
+            if (this.sessionsService) {
+                const activeSessions = await this.sessionsService.listActiveSessions();
+                const agentSession = activeSessions.find((s) => s.agentId === agentId);
+                if (agentSession && agentSession.tmuxSessionId) {
+                    await this.chatService.acknowledgeInvite(threadId, messageId, agentId, agentSession.tmuxSessionId);
+                }
+            }
+            this.terminalGateway.broadcastEvent(`chat/${threadId}`, 'message.read', {
+                messageId,
+                agentId: agentId,
+                readAt: now,
+            });
+            let agentName = validated.agent_name ?? '';
+            if (!agentName) {
+                try {
+                    const a = await this.storage.getAgent(agentId);
+                    agentName = a.name;
+                }
+                catch { }
+            }
+            const response = {
+                threadId,
+                messageId,
+                agentId: agentId,
+                agentName,
+                acknowledged: true,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            logger.error({ error, params: validated }, 'chatAck failed');
+            return {
+                success: false,
+                error: {
+                    code: 'CHAT_ACK_FAILED',
+                    message: error instanceof Error ? error.message : 'Failed to acknowledge message',
+                },
+            };
+        }
+    }
+    async chatListMembers(params) {
+        if (!this.chatService || !this.sessionsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'Chat members listing requires full app context (not available in standalone MCP mode)',
+                },
+            };
+        }
+        const validated = mcp_dto_1.ChatListMembersParamsSchema.parse(params);
+        try {
+            const thread = await this.chatService.getThread(validated.thread_id);
+            const memberIds = thread.members ?? [];
+            if (memberIds.length === 0) {
+                const emptyResponse = {
+                    thread: {
+                        id: thread.id,
+                        title: thread.title,
+                    },
+                    members: [],
+                    total: 0,
+                };
+                return { success: true, data: emptyResponse };
+            }
+            const agents = await Promise.all(memberIds.map(async (agentId) => {
+                try {
+                    return await this.storage.getAgent(agentId);
+                }
+                catch (error) {
+                    logger.error({ error, agentId, threadId: thread.id }, 'Failed to resolve agent for chat members');
+                    throw error;
+                }
+            }));
+            const activeSessions = await this.sessionsService.listActiveSessions();
+            const onlineAgents = new Set(activeSessions.map((session) => session.agentId));
+            const members = agents.map((agent) => ({
+                agent_id: agent.id,
+                agent_name: agent.name,
+                online: onlineAgents.has(agent.id),
+            }));
+            const response = {
+                thread: {
+                    id: thread.id,
+                    title: thread.title,
+                },
+                members,
+                total: members.length,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof common_1.NotFoundException || error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NOT_FOUND',
+                        message: `Thread ${validated.thread_id} was not found.`,
+                    },
+                };
+            }
+            logger.error({ error, params: validated }, 'chatListMembers failed');
+            return {
+                success: false,
+                error: {
+                    code: 'CHAT_LIST_MEMBERS_FAILED',
+                    message: error instanceof Error ? error.message : 'Failed to list chat members',
+                },
+            };
+        }
+    }
+    async chatReadHistory(params) {
+        if (!this.chatService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'Chat history requires full app context (not available in standalone MCP mode)',
+                },
+            };
+        }
+        const validated = mcp_dto_1.ChatReadHistoryParamsSchema.parse(params);
+        try {
+            const thread = await this.chatService.getThread(validated.thread_id);
+            const limit = validated.limit ?? 50;
+            const validatedWithExcludeSystem = validated;
+            const excludeSystem = typeof validatedWithExcludeSystem.exclude_system === 'boolean'
+                ? validatedWithExcludeSystem.exclude_system
+                : true;
+            const messagesList = await this.chatService.listMessages(validated.thread_id, {
+                since: validated.since,
+                limit,
+                offset: 0,
+            });
+            const authorIds = new Set();
+            const targetIds = new Set();
+            for (const m of messagesList.items) {
+                if (m.authorAgentId)
+                    authorIds.add(m.authorAgentId);
+                if (m.targets)
+                    for (const t of m.targets)
+                        targetIds.add(t);
+            }
+            const idToName = new Map();
+            const toLoad = Array.from(new Set([...authorIds, ...targetIds]));
+            for (const id of toLoad) {
+                try {
+                    const a = await this.storage.getAgent(id);
+                    idToName.set(id, a.name);
+                }
+                catch {
+                }
+            }
+            const filteredItems = excludeSystem
+                ? messagesList.items.filter((m) => m.authorType !== 'system')
+                : messagesList.items;
+            const messages = filteredItems.map((m) => {
+                const base = {
+                    id: m.id,
+                    author_type: m.authorType,
+                    author_agent_id: m.authorAgentId ?? null,
+                    author_agent_name: m.authorAgentId ? (idToName.get(m.authorAgentId) ?? null) : null,
+                    content: m.content,
+                    created_at: m.createdAt,
+                    targets: m.targets,
+                };
+                if (m.targets && m.targets.length > 0) {
+                    const names = m.targets
+                        .map((tid) => idToName.get(tid))
+                        .filter((n) => typeof n === 'string' && n.length > 0);
+                    if (names.length > 0) {
+                        base.target_agent_names = names;
+                    }
+                }
+                return base;
+            });
+            const response = {
+                thread: {
+                    id: thread.id,
+                    title: thread.title,
+                },
+                messages,
+                has_more: messages.length === limit,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof common_1.NotFoundException || error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NOT_FOUND',
+                        message: `Thread ${validated.thread_id} was not found.`,
+                    },
+                };
+            }
+            logger.error({ error, params: validated }, 'chatReadHistory failed');
+            return {
+                success: false,
+                error: {
+                    code: 'CHAT_READ_HISTORY_FAILED',
+                    message: error instanceof Error ? error.message : 'Failed to read chat history',
+                },
+            };
+        }
+    }
+    async activityStart(params) {
+        if (!this.chatService) {
+            return {
+                success: false,
+                error: { code: 'SERVICE_UNAVAILABLE', message: 'Chat service unavailable' },
+            };
+        }
+        const validated = mcp_dto_1.ActivityStartParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project)
+            return resolution.error;
+        const project = resolution.project;
+        const agentRes = await this.resolveAgentByNameUnique(project.id, validated.agentName);
+        if (!('id' in agentRes))
+            return agentRes;
+        const agentId = agentRes.id;
+        let threadId = validated.threadId;
+        if (threadId) {
+            const thread = await this.chatService.getThread(threadId);
+            const members = thread.members ?? [];
+            if (!members.includes(agentId)) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'AGENT_NOT_IN_THREAD',
+                        message: `Agent ${validated.agentName} is not a member of thread ${threadId}`,
+                    },
+                };
+            }
+        }
+        else {
+            const direct = await this.chatService.createDirectThread({ projectId: project.id, agentId });
+            threadId = direct.id;
+        }
+        const result = await this.chatService.startActivity(threadId, agentId, validated.title, {
+            announce: validated.announce,
+        });
+        const response = {
+            activity_id: result.activityId,
+            thread_id: threadId,
+            start_message_id: result.startMessageId,
+            started_at: result.startedAt,
+            auto_finished_prior: result.autoFinishedPrior,
+        };
+        return { success: true, data: response };
+    }
+    async activityFinish(params) {
+        if (!this.chatService) {
+            return {
+                success: false,
+                error: { code: 'SERVICE_UNAVAILABLE', message: 'Chat service unavailable' },
+            };
+        }
+        const validated = mcp_dto_1.ActivityFinishParamsSchema.parse(params);
+        const resolution = await this.resolveProject(validated.path);
+        if (!resolution.project)
+            return resolution.error;
+        const project = resolution.project;
+        const agentRes = await this.resolveAgentByNameUnique(project.id, validated.agentName);
+        if (!('id' in agentRes))
+            return agentRes;
+        const agentId = agentRes.id;
+        let threadId = validated.threadId;
+        if (threadId) {
+            const thread = await this.chatService.getThread(threadId);
+            const members = thread.members ?? [];
+            if (!members.includes(agentId)) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'AGENT_NOT_IN_THREAD',
+                        message: `Agent ${validated.agentName} is not a member of thread ${threadId}`,
+                    },
+                };
+            }
+        }
+        else {
+            const direct = await this.chatService.createDirectThread({ projectId: project.id, agentId });
+            threadId = direct.id;
+        }
+        try {
+            const result = await this.chatService.finishActivity(threadId, agentId, {
+                message: validated.message,
+                status: validated.status,
+            });
+            const response = {
+                activity_id: result.activityId,
+                thread_id: threadId,
+                finish_message_id: result.finishMessageId,
+                started_at: result.startedAt,
+                finished_at: result.finishedAt,
+                status: result.status,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.ValidationError || error instanceof common_2.BadRequestException) {
+                return {
+                    success: false,
+                    error: { code: 'NO_RUNNING_ACTIVITY', message: 'No running activity to finish' },
+                };
+            }
+            throw error;
+        }
+    }
+    mapStatusSummary(status) {
+        return {
+            id: status.id,
+            name: status.label,
+            position: status.position,
+            color: status.color,
+        };
+    }
+    mapEpicSummary(epic, agentNameById) {
+        const summary = {
+            id: epic.id,
+            title: epic.title,
+            description: epic.description ?? null,
+            statusId: epic.statusId,
+            version: epic.version,
+        };
+        if (epic.agentId && agentNameById) {
+            const agentName = agentNameById.get(epic.agentId);
+            if (agentName) {
+                summary.agentName = agentName;
+            }
+        }
+        if (epic.parentId) {
+            summary.parentId = epic.parentId;
+        }
+        return summary;
+    }
+    mapEpicChild(epic) {
+        return {
+            id: epic.id,
+            title: epic.title,
+            statusId: epic.statusId,
+        };
+    }
+    mapEpicParent(epic) {
+        return {
+            id: epic.id,
+            title: epic.title,
+            description: epic.description ?? null,
+        };
+    }
+    mapEpicComment(comment) {
+        return {
+            id: comment.id,
+            authorName: comment.authorName,
+            content: comment.content,
+            createdAt: comment.createdAt,
+        };
+    }
+    mapDocumentSummary(document) {
+        return {
+            id: document.id,
+            projectId: document.projectId,
+            title: document.title,
+            slug: document.slug,
+            tags: document.tags,
+            archived: document.archived,
+            version: document.version,
+            updatedAt: document.updatedAt,
+        };
+    }
+    mapDocumentDetail(document) {
+        const summary = this.mapDocumentSummary(document);
+        return {
+            ...summary,
+            contentMd: document.contentMd,
+            createdAt: document.createdAt,
+        };
+    }
+    mapPromptSummary(prompt) {
+        return {
+            id: prompt.id,
+            projectId: prompt.projectId,
+            title: prompt.title,
+            content: prompt.content,
+            tags: prompt.tags,
+            version: prompt.version,
+            createdAt: prompt.createdAt,
+            updatedAt: prompt.updatedAt,
+        };
+    }
+    extractLinkSlugs(content) {
+        const regex = /\[\[([A-Za-z0-9_\-./]+)\]\]/g;
+        const seen = new Set();
+        const slugs = [];
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const slug = match[1].trim();
+            if (slug && !seen.has(slug)) {
+                seen.add(slug);
+                slugs.push(slug);
+            }
+        }
+        return slugs;
+    }
+    escapeForRegex(value) {
+        return value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+    async collectDocumentLinks(document) {
+        const cache = new Map();
+        cache.set(document.slug, document);
+        const slugs = this.extractLinkSlugs(document.contentMd);
+        const projectId = document.projectId ?? null;
+        const links = [];
+        for (const slug of slugs) {
+            const linked = await this.loadDocumentBySlug(projectId, slug, cache);
+            if (linked) {
+                links.push({
+                    slug,
+                    title: linked.title,
+                    id: linked.id,
+                    projectId: linked.projectId,
+                    exists: true,
+                });
+            }
+            else {
+                links.push({ slug, exists: false });
+            }
+        }
+        return { links, cache };
+    }
+    async buildInlineResolution(document, cache, maxDepth, maxBytes) {
+        const effectiveDepth = Math.max(0, maxDepth);
+        const path = new Set([document.slug]);
+        const result = await this.inlineDocumentContent(document.contentMd, document.projectId ?? null, 0, { maxDepth: effectiveDepth, maxBytes }, cache, path);
+        const limited = this.applyByteLimit(result.content, maxBytes);
+        return {
+            contentMd: limited.content,
+            depthUsed: Math.min(result.depthUsed, effectiveDepth),
+            bytes: limited.bytes,
+            truncated: limited.truncated || result.truncated,
+        };
+    }
+    async inlineDocumentContent(content, projectId, depth, options, cache, path) {
+        if (options.maxDepth === 0 || depth >= options.maxDepth) {
+            const bytes = Buffer.byteLength(content, 'utf8');
+            return { content, depthUsed: depth, bytes, truncated: false };
+        }
+        let workingContent = content;
+        let depthUsed = depth;
+        const slugs = this.extractLinkSlugs(content);
+        for (const slug of slugs) {
+            if (depth >= options.maxDepth) {
+                break;
+            }
+            if (path.has(slug)) {
+                continue;
+            }
+            const linked = await this.loadDocumentBySlug(projectId, slug, cache);
+            if (!linked) {
+                continue;
+            }
+            path.add(slug);
+            const childResult = await this.inlineDocumentContent(linked.contentMd, linked.projectId ?? projectId, depth + 1, options, cache, path);
+            path.delete(slug);
+            depthUsed = Math.max(depthUsed, childResult.depthUsed);
+            const snippet = this.buildInlineSnippet(linked, childResult.content, depth + 1);
+            const pattern = new RegExp(`\\[\\[${this.escapeForRegex(slug)}\\]\\]`, 'g');
+            workingContent = workingContent.replace(pattern, snippet);
+        }
+        const bytes = Buffer.byteLength(workingContent, 'utf8');
+        return {
+            content: workingContent,
+            depthUsed: Math.max(depthUsed, depth),
+            bytes,
+            truncated: false,
+        };
+    }
+    buildInlineSnippet(document, content, depth) {
+        const headingLevel = Math.min(6, 2 + depth);
+        const heading = `${'#'.repeat(headingLevel)} ${document.title || document.slug}`;
+        return `\n\n---\n${heading}\n\n${content}\n---\n\n`;
+    }
+    async loadDocumentBySlug(projectId, slug, cache) {
+        if (cache.has(slug)) {
+            return cache.get(slug) ?? null;
+        }
+        try {
+            const linked = await this.storage.getDocument({ projectId, slug });
+            cache.set(slug, linked);
+            return linked;
+        }
+        catch (error) {
+            cache.set(slug, null);
+            return null;
+        }
+    }
+    applyByteLimit(content, maxBytes) {
+        const bytes = Buffer.byteLength(content, 'utf8');
+        if (bytes <= maxBytes) {
+            return { content, bytes, truncated: false };
+        }
+        const buffer = Buffer.from(content, 'utf8');
+        const truncatedBuffer = buffer.subarray(0, maxBytes);
+        return {
+            content: truncatedBuffer.toString('utf8'),
+            bytes: maxBytes,
+            truncated: true,
+        };
+    }
+    async resolveDocumentResource(uri) {
+        const spec = uri.slice('doc://'.length);
+        const slashIndex = spec.indexOf('/');
+        if (slashIndex === -1) {
+            throw new Error(`Invalid document resource URI: ${uri}`);
+        }
+        const projectPart = spec.slice(0, slashIndex);
+        const slugPart = spec.slice(slashIndex + 1);
+        const projectSlug = decodeURIComponent(projectPart);
+        const documentSlug = decodeURIComponent(slugPart);
+        const projectIdCandidate = await this.findProjectIdBySlug(projectSlug);
+        if (projectIdCandidate === undefined) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: `Unknown project slug: ${projectSlug}`,
+                },
+            };
+        }
+        try {
+            const document = await this.storage.getDocument({
+                projectId: projectIdCandidate ?? null,
+                slug: documentSlug,
+            });
+            return {
+                success: true,
+                data: {
+                    uri,
+                    mimeType: 'text/markdown',
+                    content: document.contentMd,
+                    document: this.mapDocumentDetail(document),
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: 'DOCUMENT_NOT_FOUND',
+                    message: `Document not found: ${documentSlug}`,
+                },
+            };
+        }
+    }
+    async resolvePromptResource(uri) {
+        const spec = uri.slice('prompt://'.length);
+        if (!spec) {
+            throw new Error(`Invalid prompt resource URI: ${uri}`);
+        }
+        const atIndex = spec.lastIndexOf('@');
+        const namePart = atIndex === -1 ? spec : spec.slice(0, atIndex);
+        const versionPart = atIndex === -1 ? undefined : spec.slice(atIndex + 1);
+        const name = decodeURIComponent(namePart).trim();
+        if (!name) {
+            throw new Error(`Prompt name missing in URI: ${uri}`);
+        }
+        let version;
+        if (versionPart && versionPart.length > 0) {
+            version = Number(versionPart);
+            if (!Number.isFinite(version) || version <= 0) {
+                throw new Error(`Invalid prompt version in URI: ${uri}`);
+            }
+        }
+        const list = await this.storage.listPrompts(null, undefined);
+        const candidates = list.items.filter((prompt) => prompt.title === name && (version === undefined || prompt.version === version));
+        const selected = candidates.find((prompt) => prompt.projectId === null) ?? candidates[0];
+        if (!selected) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROMPT_NOT_FOUND',
+                    message: `Prompt not found: ${name}${version ? `@${version}` : ''}`,
+                },
+            };
+        }
+        const prompt = await this.storage.getPrompt(selected.id);
+        return {
+            success: true,
+            data: {
+                uri,
+                mimeType: 'text/markdown',
+                content: prompt.content,
+                prompt: this.mapPromptSummary(prompt),
+            },
+        };
+    }
+    async findProjectIdBySlug(projectSlug) {
+        if (!projectSlug || projectSlug === 'global') {
+            return null;
+        }
+        const projects = await this.storage.listProjects({ limit: 1000, offset: 0 });
+        const match = projects.items.find((project) => this.slugifyProjectName(project.name) === projectSlug);
+        return match?.id;
+    }
+    slugifyProjectName(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/(^-|-$)/g, '');
+    }
+};
+exports.McpService = McpService;
+exports.McpService = McpService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
+    __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => chat_service_1.ChatService))),
+    __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => sessions_service_1.SessionsService))),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_gateway_1.TerminalGateway))),
+    __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => epics_service_1.EpicsService))),
+    __metadata("design:paramtypes", [Object, chat_service_1.ChatService,
+        sessions_service_1.SessionsService,
+        terminal_gateway_1.TerminalGateway,
+        epics_service_1.EpicsService])
+], McpService);
+//# sourceMappingURL=mcp.service.js.map