devchain-cli 0.10.4 → 0.11.0

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

@@ -1,43 +1,10 @@
 "use strict";
-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 __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 __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;
-    };
-})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -59,28 +26,22 @@ const guests_service_1 = require("../../guests/services/guests.service");
 const reviews_service_1 = require("../../reviews/services/reviews.service");
 const skills_service_1 = require("../../skills/services/skills.service");
 const logger_1 = require("../../../common/logging/logger");
-const schema_registry_1 = require("../dtos/schema-registry");
-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 path_validation_1 = require("../../../common/validation/path-validation");
-const common_2 = require("@nestjs/common");
 const zod_1 = require("zod");
+const document_link_resolver_1 = require("./utils/document-link-resolver");
+const epic_tools_1 = require("./handlers/epic-tools");
+const chat_tools_1 = require("./handlers/chat-tools");
+const activity_tools_1 = require("./handlers/activity-tools");
+const record_tools_1 = require("./handlers/record-tools");
+const document_tools_1 = require("./handlers/document-tools");
+const prompt_tools_1 = require("./handlers/prompt-tools");
+const skill_tools_1 = require("./handlers/skill-tools");
+const session_tools_1 = require("./handlers/session-tools");
+const review_tools_1 = require("./handlers/review-tools");
 const param_suggestion_1 = require("../utils/param-suggestion");
+const session_context_resolver_1 = require("./utils/session-context-resolver");
+const resource_resolver_1 = require("./utils/resource-resolver");
 const logger = (0, logger_1.createLogger)('McpService');
-function getActorFromContext(ctx) {
-    if (ctx.type === 'agent') {
-        return ctx.agent;
-    }
-    else if (ctx.type === 'guest') {
-        return {
-            id: ctx.guest.id,
-            name: ctx.guest.name,
-            projectId: ctx.guest.projectId,
-        };
-    }
-    return null;
-}
 function redactSessionId(sessionId) {
     if (!sessionId)
         return '(none)';
@@ -95,6 +56,45 @@ function redactParams(params) {
     }
     return params;
 }
+const TOOL_HANDLER_ENTRIES = [
+    ['devchain_create_record', record_tools_1.handleCreateRecord],
+    ['devchain_update_record', record_tools_1.handleUpdateRecord],
+    ['devchain_get_record', record_tools_1.handleGetRecord],
+    ['devchain_list_records', record_tools_1.handleListRecords],
+    ['devchain_add_tags', record_tools_1.handleAddTags],
+    ['devchain_remove_tags', record_tools_1.handleRemoveTags],
+    ['devchain_list_documents', document_tools_1.handleListDocuments],
+    ['devchain_get_document', document_tools_1.handleGetDocument],
+    ['devchain_create_document', document_tools_1.handleCreateDocument],
+    ['devchain_update_document', document_tools_1.handleUpdateDocument],
+    ['devchain_list_prompts', prompt_tools_1.handleListPrompts],
+    ['devchain_get_prompt', prompt_tools_1.handleGetPrompt],
+    ['devchain_list_skills', skill_tools_1.handleListSkills],
+    ['devchain_get_skill', skill_tools_1.handleGetSkill],
+    ['devchain_list_agents', epic_tools_1.handleListAgents],
+    ['devchain_get_agent_by_name', epic_tools_1.handleGetAgentByName],
+    ['devchain_list_statuses', epic_tools_1.handleListStatuses],
+    ['devchain_list_epics', epic_tools_1.handleListEpics],
+    ['devchain_list_assigned_epics_tasks', epic_tools_1.handleListAssignedEpicsTasks],
+    ['devchain_create_epic', epic_tools_1.handleCreateEpic],
+    ['devchain_get_epic_by_id', epic_tools_1.handleGetEpicById],
+    ['devchain_add_epic_comment', epic_tools_1.handleAddEpicComment],
+    ['devchain_update_epic', epic_tools_1.handleUpdateEpic],
+    ['devchain_send_message', chat_tools_1.handleSendMessage],
+    ['devchain_chat_ack', chat_tools_1.handleChatAck],
+    ['devchain_chat_list_members', chat_tools_1.handleChatListMembers],
+    ['devchain_chat_read_history', chat_tools_1.handleChatReadHistory],
+    ['devchain_activity_start', activity_tools_1.handleActivityStart],
+    ['devchain_activity_finish', activity_tools_1.handleActivityFinish],
+    ['devchain_list_sessions', session_tools_1.handleListSessions],
+    ['devchain_register_guest', session_tools_1.handleRegisterGuest],
+    ['devchain_list_reviews', review_tools_1.handleListReviews],
+    ['devchain_get_review', review_tools_1.handleGetReview],
+    ['devchain_get_review_comments', review_tools_1.handleGetReviewComments],
+    ['devchain_reply_comment', review_tools_1.handleReplyComment],
+    ['devchain_resolve_comment', review_tools_1.handleResolveComment],
+    ['devchain_apply_suggestion', review_tools_1.handleApplySuggestion],
+];
 let McpService = class McpService {
     constructor(storage, chatService, sessionsService, messagePoolService, terminalGateway, tmuxService, epicsService, settingsService, guestsService, skillsService, reviewsService) {
         this.storage = storage;
@@ -111,141 +111,63 @@ let McpService = class McpService {
         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);
+        this.instructionsResolver = new instructions_resolver_1.InstructionsResolver(this.storage, (document, cache, maxDepth, maxBytes) => (0, document_link_resolver_1.buildInlineResolution)(this.storage, document, cache, maxDepth, maxBytes), this.featureFlags);
+        this.sessionContextResolver = new session_context_resolver_1.SessionContextResolver(this.storage, this.sessionsService, this.guestsService, this.tmuxService);
+        this.resourceResolver = new resource_resolver_1.ResourceResolver(this.storage);
+        this.toolHandlers = new Map(TOOL_HANDLER_ENTRIES);
     }
-    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 };
+    buildHandlerContext() {
+        return {
+            storage: this.storage,
+            chatService: this.chatService,
+            sessionsService: this.sessionsService,
+            messagePoolService: this.messagePoolService,
+            terminalGateway: this.terminalGateway,
+            tmuxService: this.tmuxService,
+            epicsService: this.epicsService,
+            settingsService: this.settingsService,
+            guestsService: this.guestsService,
+            skillsService: this.skillsService,
+            reviewsService: this.reviewsService,
+            instructionsResolver: this.instructionsResolver,
+            featureFlags: this.featureFlags,
+            defaultInlineMaxBytes: this.DEFAULT_INLINE_MAX_BYTES,
+            resolveSessionContext: (sessionId) => this.resolveSessionContext(sessionId),
+        };
     }
     async handleToolCall(tool, params) {
         const normalizedParams = params ?? {};
         const normalizedTool = tool.replace(/[.\-/]/g, '_');
         try {
             logger.info({ tool: normalizedTool, originalTool: tool, params: redactParams(normalizedParams) }, 'Handling MCP tool call');
-            switch (normalizedTool) {
-                case 'devchain_create_record':
-                    return await this.createRecord(normalizedParams);
-                case 'devchain_update_record':
-                    return await this.updateRecord(normalizedParams);
-                case 'devchain_get_record':
-                    return await this.getRecord(normalizedParams);
-                case 'devchain_list_records':
-                    return await this.listRecords(normalizedParams);
-                case 'devchain_add_tags':
-                    return await this.addTags(normalizedParams);
-                case 'devchain_remove_tags':
-                    return await this.removeTags(normalizedParams);
-                case 'devchain_list_documents':
-                    return await this.listDocuments(normalizedParams);
-                case 'devchain_get_document':
-                    return await this.getDocument(normalizedParams);
-                case 'devchain_create_document':
-                    return await this.createDocument(normalizedParams);
-                case 'devchain_update_document':
-                    return await this.updateDocument(normalizedParams);
-                case 'devchain_list_prompts':
-                    return await this.listPrompts(normalizedParams);
-                case 'devchain_get_prompt':
-                    return await this.getPrompt(normalizedParams);
-                case 'devchain_list_skills':
-                    return await this.listSkills(normalizedParams);
-                case 'devchain_get_skill':
-                    return await this.getSkill(normalizedParams);
-                case 'devchain_list_agents':
-                    return await this.listAgents(normalizedParams);
-                case 'devchain_get_agent_by_name':
-                    return await this.getAgentByName(normalizedParams);
-                case 'devchain_list_statuses':
-                    return await this.listStatuses(normalizedParams);
-                case 'devchain_list_epics':
-                    return await this.listEpics(normalizedParams);
-                case 'devchain_list_assigned_epics_tasks':
-                    return await this.listAssignedEpicsTasks(normalizedParams);
-                case 'devchain_create_epic':
-                    return await this.createEpic(normalizedParams);
-                case 'devchain_get_epic_by_id':
-                    return await this.getEpicById(normalizedParams);
-                case 'devchain_add_epic_comment':
-                    return await this.addEpicComment(normalizedParams);
-                case 'devchain_update_epic':
-                    return await this.updateEpic(normalizedParams);
-                case 'notifications_initialized':
-                    return { success: true, data: { acknowledged: true } };
-                case 'devchain_send_message':
-                    return await this.sendMessage(normalizedParams);
-                case 'devchain_chat_ack':
-                    return await this.chatAck(normalizedParams);
-                case 'devchain_chat_list_members':
-                    return await this.chatListMembers(normalizedParams);
-                case 'devchain_chat_read_history':
-                    return await this.chatReadHistory(normalizedParams);
-                case 'devchain_activity_start':
-                    return await this.activityStart(normalizedParams);
-                case 'devchain_activity_finish':
-                    return await this.activityFinish(normalizedParams);
-                case 'devchain_list_sessions':
-                    schema_registry_1.ListSessionsParamsSchema.parse(normalizedParams);
-                    return await this.listSessions();
-                case 'devchain_register_guest':
-                    return await this.registerGuest(normalizedParams);
-                case 'devchain_list_reviews':
-                    return await this.listReviews(normalizedParams);
-                case 'devchain_get_review':
-                    return await this.getReview(normalizedParams);
-                case 'devchain_get_review_comments':
-                    return await this.getReviewComments(normalizedParams);
-                case 'devchain_reply_comment':
-                    return await this.replyComment(normalizedParams);
-                case 'devchain_resolve_comment':
-                    return await this.resolveComment(normalizedParams);
-                case 'devchain_apply_suggestion':
-                    return await this.applySuggestion(normalizedParams);
-                default:
-                    logger.warn({ tool: normalizedTool }, 'Unknown MCP tool');
-                    return {
-                        success: false,
-                        error: {
-                            code: 'UNKNOWN_TOOL',
-                            message: `Unknown tool: ${tool}`,
-                        },
-                    };
+            if (normalizedTool === 'notifications_initialized') {
+                return { success: true, data: { acknowledged: true } };
+            }
+            const handler = this.toolHandlers.get(normalizedTool);
+            if (!handler) {
+                logger.warn({ tool: normalizedTool }, 'Unknown MCP tool');
+                return {
+                    success: false,
+                    error: {
+                        code: 'UNKNOWN_TOOL',
+                        message: `Unknown tool: ${tool}`,
+                    },
+                };
             }
+            return await handler(this.buildHandlerContext(), normalizedParams);
         }
         catch (error) {
             logger.error({ tool, error }, 'MCP tool call failed');
             if (error instanceof zod_1.ZodError) {
                 const suggestions = [];
                 for (const issue of error.issues) {
-                    if (issue.code === 'unrecognized_keys') {
-                        const unknownKeys = issue.keys;
-                        for (const key of unknownKeys) {
-                            const suggestion = (0, param_suggestion_1.suggestNestedPath)(key, normalizedTool);
-                            if (suggestion) {
-                                suggestions.push(suggestion);
-                            }
-                        }
+                    if (issue.code !== 'unrecognized_keys')
+                        continue;
+                    const unknownKeys = issue.keys;
+                    for (const key of unknownKeys) {
+                        const suggestion = (0, param_suggestion_1.suggestNestedPath)(key, normalizedTool);
+                        if (suggestion)
+                            suggestions.push(suggestion);
                     }
                 }
                 return {
@@ -272,19 +194,7 @@ let McpService = class McpService {
     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}`,
-                },
-            };
+            return await this.resourceResolver.resolve(uri);
         }
         catch (error) {
             logger.error({ uri, error }, 'MCP resource handler failed');
@@ -297,3150 +207,8 @@ let McpService = class McpService {
             };
         }
     }
-    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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        logger.debug({ sessionId: redactSessionId(validated.sessionId), projectId: project.id }, 'Resolved session 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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        logger.debug({ sessionId: redactSessionId(validated.sessionId), projectId: project.id }, 'Resolved session 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);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        const projectId = project.id;
-        const result = await this.storage.listPrompts({
-            projectId: projectId ?? null,
-            q: validated.q,
-        });
-        let items = result.items;
-        if (validated.tags?.length) {
-            items = items.filter((prompt) => validated.tags.every((tag) => prompt.tags.includes(tag)));
-        }
-        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) {
-            if (!validated.sessionId) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'INVALID_PARAMS',
-                        message: 'sessionId is required when querying prompt by name',
-                    },
-                };
-            }
-            const ctx = await this.resolveSessionContext(validated.sessionId);
-            if (!ctx.success)
-                return ctx;
-            const { project } = ctx.data;
-            if (!project) {
-                return {
-                    success: false,
-                    error: { code: 'PROJECT_NOT_FOUND', message: 'No project associated with this session' },
-                };
-            }
-            const projectId = project.id;
-            const list = await this.storage.listPrompts({ projectId: projectId ?? null });
-            const found = list.items.find((item) => {
-                if (item.title !== validated.name) {
-                    return false;
-                }
-                if (validated.version !== undefined) {
-                    return item.version === validated.version;
-                }
-                return true;
-            });
-            if (found) {
-                prompt = await this.storage.getPrompt(found.id);
-            }
-        }
-        if (!prompt) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROMPT_NOT_FOUND',
-                    message: validated.id
-                        ? `Prompt with id "${validated.id}" not found`
-                        : `Prompt "${validated.name}"${validated.version ? ` version ${validated.version}` : ''} not found`,
-                },
-            };
-        }
-        const response = {
-            prompt: this.mapPromptDetail(prompt),
-        };
-        return { success: true, data: response };
-    }
-    async listSkills(params) {
-        if (!this.skillsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'Skill listing requires SkillsService to be available',
-                },
-            };
-        }
-        const validated = mcp_dto_1.ListSkillsParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        const projectSkills = await this.skillsService.listDiscoverable(project.id, { q: validated.q });
-        const response = {
-            skills: projectSkills.map((skill) => this.mapSkillListItem(skill)),
-            total: projectSkills.length,
-        };
-        return { success: true, data: response };
-    }
-    async getSkill(params) {
-        if (!this.skillsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'Skill retrieval requires SkillsService to be available',
-                },
-            };
-        }
-        const validated = mcp_dto_1.GetSkillParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const sessionCtx = ctx.data;
-        const { project } = sessionCtx;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        const normalizedSlug = validated.slug.trim().toLowerCase();
-        let skill;
-        try {
-            skill = await this.skillsService.getSkillBySlug(normalizedSlug);
-        }
-        catch (error) {
-            if (error instanceof error_types_1.NotFoundError) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'SKILL_NOT_FOUND',
-                        message: `Skill "${validated.slug}" was not found.`,
-                    },
-                };
-            }
-            if (error instanceof error_types_1.ValidationError) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'VALIDATION_ERROR',
-                        message: error.message,
-                        data: error.details,
-                    },
-                };
-            }
-            throw error;
-        }
-        const actor = getActorFromContext(sessionCtx);
-        await this.skillsService.logUsage(skill.id, skill.slug, project.id, actor?.id ?? null, actor?.name ?? null);
-        const response = this.mapSkillDetail(skill);
-        return { success: true, data: response };
-    }
-    async listAgents(params) {
-        const validated = mcp_dto_1.ListAgentsParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        const limit = validated.limit ?? 100;
-        const offset = validated.offset ?? 0;
-        const normalizedQuery = validated.q?.toLowerCase();
-        const MAX_COMBINED_FETCH = 1000;
-        const [agentsResult, guests] = await Promise.all([
-            this.storage.listAgents(project.id, { limit: MAX_COMBINED_FETCH, offset: 0 }),
-            this.storage.listGuests(project.id),
-        ]);
-        const [agentPresence, tmuxSessions] = await Promise.all([
-            this.sessionsService
-                ? this.sessionsService.getAgentPresence(project.id)
-                : Promise.resolve(new Map()),
-            this.tmuxService
-                ? this.tmuxService.listAllSessionNames()
-                : Promise.resolve(new Set()),
-        ]);
-        const agentItems = agentsResult.items.map((agent) => ({
-            id: agent.id,
-            name: agent.name,
-            profileId: agent.profileId,
-            description: agent.description,
-            type: 'agent',
-            online: agentPresence.get(agent.id)?.online ?? false,
-        }));
-        const guestItems = guests.map((guest) => ({
-            id: guest.id,
-            name: guest.name,
-            profileId: null,
-            description: guest.description,
-            type: 'guest',
-            online: tmuxSessions.has(guest.tmuxSessionId),
-        }));
-        let allItems = [...agentItems, ...guestItems].sort((a, b) => {
-            const nameCompare = a.name.localeCompare(b.name);
-            if (nameCompare !== 0)
-                return nameCompare;
-            return a.type === 'agent' ? -1 : 1;
-        });
-        if (normalizedQuery) {
-            allItems = allItems.filter((item) => item.name.toLowerCase().includes(normalizedQuery));
-        }
-        const total = allItems.length;
-        const paginatedItems = allItems.slice(offset, offset + limit);
-        const response = {
-            agents: paginatedItems,
-            total,
-            limit,
-            offset,
-        };
-        return { success: true, data: response };
-    }
-    async getAgentByName(params) {
-        const validated = mcp_dto_1.GetAgentByNameParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        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,
-                description: agentWithProfile.description,
-                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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        const result = await this.storage.listStatuses(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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        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,
-            excludeMcpHidden: true,
-            parentOnly: true,
-        });
-        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 parentIds = result.items.map((epic) => epic.id);
-        const subEpicsMap = await this.storage.listSubEpicsForParents(project.id, parentIds, {
-            excludeMcpHidden: true,
-            type: 'active',
-            limitPerParent: 50,
-        });
-        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);
-            }
-            const subEpics = subEpicsMap.get(epic.id) ?? [];
-            summary.subEpics = subEpics.map((subEpic) => {
-                const child = this.mapEpicChild(subEpic);
-                const subStatus = statusById.get(subEpic.statusId);
-                if (subStatus) {
-                    child.status = this.mapStatusSummary(subStatus);
-                }
-                return child;
-            });
-            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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        const limit = validated.limit ?? 100;
-        const offset = validated.offset ?? 0;
-        try {
-            const result = await this.storage.listAssignedEpics(project.id, {
-                agentName: validated.agentName,
-                limit,
-                offset,
-                excludeMcpHidden: true,
-            });
-            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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        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 sessionCtx = ctx.data;
-            const actor = sessionCtx.type === 'agent'
-                ? { type: 'agent', id: sessionCtx.agent.id }
-                : sessionCtx.type === 'guest'
-                    ? { type: 'guest', id: sessionCtx.guest.id }
-                    : null;
-            const context = { actor };
-            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,
-                skillsRequired: validated.skillsRequired ?? null,
-            }, context);
-            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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        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 });
-        let parentEpic;
-        if (epic.parentId) {
-            try {
-                const parent = await this.storage.getEpic(epic.parentId);
-                if (parent.projectId === project.id) {
-                    parentEpic = 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 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);
-        }
-        if (parentEpic?.agentId)
-            agentIds.add(parentEpic.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 (parentEpic) {
-            parentSummary = this.mapEpicParent(parentEpic, agentNameById);
-        }
-        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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const sessionCtx = ctx.data;
-        const authorActor = getActorFromContext(sessionCtx);
-        if (!authorActor) {
-            return {
-                success: false,
-                error: {
-                    code: 'AGENT_REQUIRED',
-                    message: 'Session must be associated with an agent or guest to add comments',
-                },
-            };
-        }
-        const project = sessionCtx.project;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        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: authorActor.name,
-            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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        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.skillsRequired !== undefined) {
-            updateData.skillsRequired = validated.skillsRequired;
-        }
-        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 {
-            const sessionCtx = ctx.data;
-            const actor = sessionCtx.type === 'agent'
-                ? { type: 'agent', id: sessionCtx.agent.id }
-                : sessionCtx.type === 'guest'
-                    ? { type: 'guest', id: sessionCtx.guest.id }
-                    : null;
-            const context = { actor };
-            updatedEpic = await this.epicsService.updateEpic(validated.id, updateData, validated.version, context);
-        }
-        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 resolveRecipientByName(projectId, name) {
-        try {
-            const agent = await this.storage.getAgentByName(projectId, name);
-            return {
-                type: 'agent',
-                id: agent.id,
-                name: agent.name,
-            };
-        }
-        catch (error) {
-            if (!(error instanceof error_types_1.NotFoundError)) {
-                throw error;
-            }
-        }
-        const guest = await this.storage.getGuestByName(projectId, name);
-        if (guest) {
-            return {
-                type: 'guest',
-                id: guest.id,
-                name: guest.name,
-                tmuxSessionId: guest.tmuxSessionId,
-            };
-        }
-        return null;
-    }
-    async getAvailableRecipientNames(projectId) {
-        const [agentsResult, guests] = await Promise.all([
-            this.storage.listAgents(projectId, { limit: 100, offset: 0 }),
-            this.storage.listGuests(projectId),
-        ]);
-        const agentNames = agentsResult.items.map((a) => a.name);
-        const guestNames = guests.map((g) => `${g.name} (guest)`);
-        return [...agentNames, ...guestNames];
-    }
-    async sendMessage(params) {
-        if (!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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const sessionCtx = ctx.data;
-        const sender = getActorFromContext(sessionCtx);
-        const project = sessionCtx.project;
-        if (!sender) {
-            return {
-                success: false,
-                error: {
-                    code: 'AGENT_REQUIRED',
-                    message: 'Session must be associated with an agent or guest to send messages',
-                },
-            };
-        }
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (sessionCtx.type === 'guest') {
-            if (validated.threadId) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'GUEST_THREAD_NOT_ALLOWED',
-                        message: 'Guests cannot use threaded messaging. Use recipientAgentNames for direct messaging.',
-                    },
-                };
-            }
-            if (validated.recipient === 'user') {
-                return {
-                    success: false,
-                    error: {
-                        code: 'GUEST_USER_DM_NOT_ALLOWED',
-                        message: 'Guests cannot send direct messages to users.',
-                    },
-                };
-            }
-        }
-        try {
-            const autoLaunchSessions = process.env.NODE_ENV !== 'test';
-            const senderId = sender.id;
-            const senderName = sender.name;
-            const senderType = sessionCtx.type;
-            const recipientType = validated.recipient ?? 'agents';
-            const resolvedRecipients = [];
-            if (validated.recipientAgentNames && validated.recipientAgentNames.length > 0) {
-                for (const name of validated.recipientAgentNames) {
-                    const recipient = await this.resolveRecipientByName(project.id, name);
-                    if (!recipient) {
-                        const availableNames = await this.getAvailableRecipientNames(project.id);
-                        return {
-                            success: false,
-                            error: {
-                                code: 'RECIPIENT_NOT_FOUND',
-                                message: `Recipient "${name}" not found. Available: ${availableNames.join(', ') || 'none'}`,
-                            },
-                        };
-                    }
-                    if (recipient.id !== senderId) {
-                        resolvedRecipients.push(recipient);
-                    }
-                }
-            }
-            const uniqueRecipients = resolvedRecipients.filter((r, i, arr) => arr.findIndex((x) => x.id === r.id) === i);
-            if (!validated.threadId && senderId && recipientType !== 'user') {
-                if (!this.messagePoolService || !this.settingsService) {
-                    return {
-                        success: false,
-                        error: {
-                            code: 'SERVICE_UNAVAILABLE',
-                            message: 'Message pool functionality requires full app context (not available in standalone MCP mode)',
-                        },
-                    };
-                }
-                if (uniqueRecipients.length === 0) {
-                    return {
-                        success: false,
-                        error: {
-                            code: 'RECIPIENTS_REQUIRED',
-                            message: 'Recipients must be provided when sending without threadId.',
-                        },
-                    };
-                }
-                const queued = [];
-                const poolConfig = this.settingsService.getMessagePoolConfigForProject(project.id);
-                const activeSessions = this.sessionsService
-                    ? await this.sessionsService.listActiveSessions()
-                    : [];
-                for (const recipient of uniqueRecipients) {
-                    const injectionText = `\n[This message is sent from "${senderName}" ${senderType} use devchain_send_message tool for communication]\n${validated.message}\n`;
-                    if (recipient.type === 'agent') {
-                        let session = activeSessions.find((s) => s.agentId === recipient.id);
-                        let wasLaunched = false;
-                        if (!session && autoLaunchSessions && this.sessionsService) {
-                            try {
-                                const launched = await this.sessionsService.launchSession({
-                                    projectId: project.id,
-                                    agentId: recipient.id,
-                                    options: { silent: true },
-                                });
-                                session = launched;
-                                activeSessions.push(launched);
-                                wasLaunched = true;
-                            }
-                            catch {
-                            }
-                        }
-                        await this.messagePoolService.enqueue(recipient.id, injectionText, {
-                            source: 'mcp.send_message',
-                            submitKeys: ['Enter'],
-                            senderAgentId: senderId,
-                            projectId: project.id,
-                            agentName: recipient.name,
-                        });
-                        queued.push({
-                            name: recipient.name,
-                            type: 'agent',
-                            status: wasLaunched ? 'launched' : 'queued',
-                        });
-                    }
-                    else {
-                        const isOnline = this.tmuxService
-                            ? await this.tmuxService.hasSession(recipient.tmuxSessionId)
-                            : false;
-                        if (!isOnline) {
-                            queued.push({
-                                name: recipient.name,
-                                type: 'guest',
-                                status: 'failed',
-                                error: 'Recipient offline',
-                            });
-                        }
-                        else if (this.tmuxService) {
-                            try {
-                                await this.tmuxService.pasteAndSubmit(recipient.tmuxSessionId, injectionText);
-                                queued.push({
-                                    name: recipient.name,
-                                    type: 'guest',
-                                    status: 'delivered',
-                                });
-                            }
-                            catch (error) {
-                                logger.warn({ guestId: recipient.id, tmuxSessionId: recipient.tmuxSessionId, error }, 'Failed to deliver message to guest');
-                                queued.push({
-                                    name: recipient.name,
-                                    type: 'guest',
-                                    status: 'failed',
-                                    error: error instanceof Error ? error.message : 'Delivery failed',
-                                });
-                            }
-                        }
-                        else {
-                            queued.push({
-                                name: recipient.name,
-                                type: 'guest',
-                                status: 'failed',
-                                error: 'Tmux service unavailable',
-                            });
-                        }
-                    }
-                }
-                const response = {
-                    mode: 'pooled',
-                    queuedCount: queued.length,
-                    queued,
-                    estimatedDeliveryMs: poolConfig.delayMs,
-                };
-                return { success: true, data: response };
-            }
-            if (!this.chatService) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'SERVICE_UNAVAILABLE',
-                        message: 'Chat functionality requires full app context (not available in standalone MCP mode)',
-                    },
-                };
-            }
-            let threadId = validated.threadId;
-            if (!threadId && senderId) {
-                if (recipientType === 'user') {
-                    const direct = await this.chatService.createDirectThread({
-                        projectId: project.id,
-                        agentId: senderId,
-                    });
-                    threadId = direct.id;
-                }
-                else {
-                }
-            }
-            if (!threadId) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'THREAD_REQUIRED',
-                        message: 'Unable to determine thread for message delivery',
-                    },
-                };
-            }
-            const thread = await this.chatService.getThread(threadId);
-            const message = await this.chatService.createMessage(threadId, {
-                authorType: 'agent',
-                authorAgentId: senderId,
-                content: validated.message,
-            });
-            let targetAgentIds = uniqueRecipients.filter((r) => r.type === 'agent').map((r) => r.id);
-            if (senderId && thread.members && thread.members.length > 1 && targetAgentIds.length === 0) {
-                targetAgentIds = thread.members.filter((id) => id !== senderId);
-            }
-            const activeSessions = await this.sessionsService.listActiveSessions();
-            const delivered = [];
-            for (const agentId of targetAgentIds) {
-                const agent = await this.storage.getAgent(agentId);
-                let session = activeSessions.find((s) => s.agentId === agentId);
-                if (!session && autoLaunchSessions) {
-                    try {
-                        const launched = await this.sessionsService.launchSession({
-                            projectId: project.id,
-                            agentId,
-                            options: { silent: true },
-                        });
-                        session = launched;
-                        activeSessions.push(launched);
-                    }
-                    catch {
-                    }
-                }
-                if (!session) {
-                    delivered.push({ agentId, agentName: agent.name, sessionId: '', status: 'queued' });
-                    continue;
-                }
-                const injectionText = `\n[CHAT] From: ${senderName} • Thread: ${threadId}\n${validated.message}\n[ACK] tools/call { name: "devchain_chat_ack", arguments: { sessionId: "${session.id}", thread_id: "${threadId}", message_id: "${message.id}" } }\n`;
-                await this.sessionsService.injectTextIntoSession(session.id, injectionText);
-                delivered.push({
-                    agentId,
-                    agentName: agent.name,
-                    sessionId: session.id,
-                    status: 'delivered',
-                });
-            }
-            const response = {
-                mode: 'thread',
-                threadId,
-                messageId: message.id,
-                deliveryCount: delivered.filter((d) => d.status === 'delivered').length,
-                delivered,
-            };
-            return { success: true, data: response };
-        }
-        catch (error) {
-            logger.error({ error, params: redactParams(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;
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const sessionCtx = ctx.data;
-        const agent = getActorFromContext(sessionCtx);
-        if (!agent) {
-            return {
-                success: false,
-                error: {
-                    code: 'AGENT_NOT_FOUND',
-                    message: 'No agent associated with this session',
-                },
-            };
-        }
-        const agentId = agent.id;
-        try {
-            const thread = await this.chatService.getThread(threadId);
-            const memberIds = thread.members ?? [];
-            if (!memberIds.includes(agentId)) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'AGENT_NOT_IN_THREAD',
-                        message: `Agent ${agent.name} is not a member of thread ${threadId}`,
-                    },
-                };
-            }
-            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,
-                readAt: now,
-            });
-            const response = {
-                threadId,
-                messageId,
-                agentId,
-                agentName: agent.name,
-                acknowledged: true,
-            };
-            return { success: true, data: response };
-        }
-        catch (error) {
-            logger.error({ error, params: redactParams(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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const sessionCtx = ctx.data;
-        const project = sessionCtx.project;
-        const agent = getActorFromContext(sessionCtx);
-        if (sessionCtx.type === 'guest') {
-            return {
-                success: false,
-                error: {
-                    code: 'GUEST_ACTIVITY_NOT_ALLOWED',
-                    message: 'Guests cannot use activity tools.',
-                },
-            };
-        }
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!agent) {
-            return {
-                success: false,
-                error: {
-                    code: 'AGENT_NOT_FOUND',
-                    message: 'No agent associated with this session',
-                },
-            };
-        }
-        const agentId = agent.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 ${agent.name} 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 ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const sessionCtx = ctx.data;
-        const project = sessionCtx.project;
-        const agent = getActorFromContext(sessionCtx);
-        if (sessionCtx.type === 'guest') {
-            return {
-                success: false,
-                error: {
-                    code: 'GUEST_ACTIVITY_NOT_ALLOWED',
-                    message: 'Guests cannot use activity tools.',
-                },
-            };
-        }
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!agent) {
-            return {
-                success: false,
-                error: {
-                    code: 'AGENT_NOT_FOUND',
-                    message: 'No agent associated with this session',
-                },
-            };
-        }
-        const agentId = agent.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 ${agent.name} 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;
-        }
-    }
-    async listSessions() {
-        if (!this.sessionsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'Session listing requires full app context (not available in standalone MCP mode)',
-                },
-            };
-        }
-        try {
-            const activeSessions = await this.sessionsService.listActiveSessions();
-            const agentIds = [
-                ...new Set(activeSessions.map((s) => s.agentId).filter((id) => !!id)),
-            ];
-            const agentResults = await Promise.all(agentIds.map((id) => this.storage
-                .getAgent(id)
-                .catch(() => null)));
-            const agentMap = new Map(agentResults.filter((a) => a !== null).map((a) => [a.id, a]));
-            const projectIds = [
-                ...new Set(Array.from(agentMap.values())
-                    .map((a) => a.projectId)
-                    .filter((id) => !!id)),
-            ];
-            const projectResults = await Promise.all(projectIds.map((id) => this.storage.getProject(id).catch(() => null)));
-            const projectMap = new Map(projectResults.filter((p) => p !== null).map((p) => [p.id, p]));
-            const sessions = activeSessions.map((session) => {
-                const agent = session.agentId ? agentMap.get(session.agentId) : undefined;
-                const project = agent?.projectId ? projectMap.get(agent.projectId) : undefined;
-                return {
-                    sessionIdShort: session.id.slice(0, 8),
-                    agentName: agent?.name ?? 'Unknown',
-                    projectName: agent ? (project?.name ?? 'Unknown') : '',
-                    status: session.status,
-                    startedAt: session.startedAt,
-                };
-            });
-            const response = { sessions };
-            return { success: true, data: response };
-        }
-        catch (error) {
-            logger.error({ error }, 'listSessions failed');
-            return {
-                success: false,
-                error: {
-                    code: 'LIST_SESSIONS_FAILED',
-                    message: error instanceof Error ? error.message : 'Failed to list sessions',
-                },
-            };
-        }
-    }
-    async resolveSessionContext(sessionId) {
-        if (!this.sessionsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'Session resolution requires full app context (not available in standalone MCP mode)',
-                },
-            };
-        }
-        if (!sessionId || sessionId.length < 8) {
-            return {
-                success: false,
-                error: {
-                    code: 'INVALID_SESSION_ID',
-                    message: 'Session ID must be at least 8 characters (full UUID or prefix)',
-                },
-            };
-        }
-        try {
-            const activeSessions = await this.sessionsService.listActiveSessions();
-            let matchingSessions;
-            if (sessionId.length === 36) {
-                matchingSessions = activeSessions.filter((s) => s.id === sessionId);
-            }
-            else {
-                matchingSessions = activeSessions.filter((s) => s.id.startsWith(sessionId));
-            }
-            if (matchingSessions.length === 0) {
-                const guestContext = await this.tryResolveGuestContext(sessionId);
-                if (guestContext) {
-                    return { success: true, data: guestContext };
-                }
-                return {
-                    success: false,
-                    error: {
-                        code: 'SESSION_NOT_FOUND',
-                        message: `No active session or guest found matching '${sessionId}'`,
-                    },
-                };
-            }
-            if (matchingSessions.length > 1) {
-                const prefixLength = 12;
-                const matchingPrefixes = matchingSessions.map((s) => s.id.slice(0, prefixLength));
-                return {
-                    success: false,
-                    error: {
-                        code: 'AMBIGUOUS_SESSION',
-                        message: `Multiple active sessions match prefix '${sessionId}': ${matchingPrefixes.join(', ')}. Use a longer prefix (e.g., 12+ chars) or full UUID.`,
-                        data: {
-                            matchingSessionIdPrefixes: matchingPrefixes,
-                        },
-                    },
-                };
-            }
-            const session = matchingSessions[0];
-            let agent = null;
-            if (session.agentId) {
-                try {
-                    const agentEntity = await this.storage.getAgent(session.agentId);
-                    agent = {
-                        id: agentEntity.id,
-                        name: agentEntity.name,
-                        projectId: agentEntity.projectId,
-                    };
-                }
-                catch {
-                    logger.warn({ sessionId: redactSessionId(session.id), agentId: session.agentId }, 'Agent not found for session');
-                }
-            }
-            let project = null;
-            if (agent?.projectId) {
-                try {
-                    const projectEntity = await this.storage.getProject(agent.projectId);
-                    project = {
-                        id: projectEntity.id,
-                        name: projectEntity.name,
-                        rootPath: projectEntity.rootPath,
-                    };
-                }
-                catch {
-                    logger.warn({ sessionId: redactSessionId(session.id), projectId: agent.projectId }, 'Project not found for session');
-                }
-            }
-            const context = {
-                type: 'agent',
-                session: {
-                    id: session.id,
-                    agentId: session.agentId,
-                    status: session.status,
-                    startedAt: session.startedAt,
-                },
-                agent,
-                project,
-            };
-            return { success: true, data: context };
-        }
-        catch (error) {
-            logger.error({ error, sessionId: redactSessionId(sessionId) }, 'resolveSessionContext failed');
-            return {
-                success: false,
-                error: {
-                    code: 'SESSION_RESOLUTION_FAILED',
-                    message: error instanceof Error ? error.message : 'Failed to resolve session context',
-                },
-            };
-        }
-    }
-    async tryResolveGuestContext(guestId) {
-        if (!this.guestsService || !this.tmuxService) {
-            return null;
-        }
-        try {
-            let guest;
-            if (guestId.length === 36) {
-                guest = await this.storage.getGuest(guestId);
-            }
-            else {
-                const matches = await this.storage.getGuestsByIdPrefix(guestId);
-                if (matches.length === 1) {
-                    guest = matches[0];
-                }
-                else {
-                    return null;
-                }
-            }
-            const sessionAlive = await this.tmuxService.hasSession(guest.tmuxSessionId);
-            if (!sessionAlive) {
-                logger.warn({ guestId: guest.id, tmuxSessionId: guest.tmuxSessionId }, 'Guest tmux session no longer exists');
-                return null;
-            }
-            const project = await this.storage.getProject(guest.projectId);
-            const context = {
-                type: 'guest',
-                guest: {
-                    id: guest.id,
-                    name: guest.name,
-                    projectId: guest.projectId,
-                    tmuxSessionId: guest.tmuxSessionId,
-                },
-                project: {
-                    id: project.id,
-                    name: project.name,
-                    rootPath: project.rootPath,
-                },
-            };
-            return context;
-        }
-        catch (error) {
-            logger.debug({ guestId: redactSessionId(guestId), error: String(error) }, 'Failed to resolve guest context');
-            return null;
-        }
-    }
-    async registerGuest(params) {
-        if (!this.guestsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'Guest registration requires full app context',
-                },
-            };
-        }
-        const validated = mcp_dto_1.RegisterGuestParamsSchema.parse(params);
-        try {
-            const result = await this.guestsService.register({
-                name: validated.name,
-                tmuxSessionId: validated.tmuxSessionId,
-                description: validated.description,
-            });
-            const response = {
-                guestId: result.guestId,
-                name: validated.name,
-                projectId: result.projectId,
-                projectName: result.projectName,
-                isSandbox: result.isSandbox,
-                registeredAt: new Date().toISOString(),
-            };
-            logger.info({ guestId: result.guestId, projectId: result.projectId, isSandbox: result.isSandbox }, 'Guest registered successfully');
-            return { success: true, data: response };
-        }
-        catch (error) {
-            if (error instanceof error_types_1.ValidationError) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'VALIDATION_ERROR',
-                        message: error.message,
-                        data: error.details,
-                    },
-                };
-            }
-            if (error instanceof Error && error.name === 'ConflictError') {
-                return {
-                    success: false,
-                    error: {
-                        code: 'CONFLICT',
-                        message: error.message,
-                        data: error.data,
-                    },
-                };
-            }
-            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;
-        }
-        summary.tags = epic.tags ?? [];
-        summary.skillsRequired = epic.skillsRequired ?? [];
-        return summary;
-    }
-    mapEpicChild(epic) {
-        return {
-            id: epic.id,
-            title: epic.title,
-            statusId: epic.statusId,
-        };
-    }
-    mapEpicParent(epic, agentNameById) {
-        return {
-            id: epic.id,
-            title: epic.title,
-            description: epic.description ?? null,
-            agentName: epic.agentId ? (agentNameById.get(epic.agentId) ?? null) : 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,
-            contentPreview: prompt.contentPreview,
-            tags: prompt.tags,
-            version: prompt.version,
-            createdAt: prompt.createdAt,
-            updatedAt: prompt.updatedAt,
-        };
-    }
-    mapPromptDetail(prompt) {
-        const PREVIEW_LENGTH = 200;
-        const contentPreview = prompt.content.length > PREVIEW_LENGTH
-            ? prompt.content.slice(0, PREVIEW_LENGTH) + '…'
-            : prompt.content;
-        return {
-            id: prompt.id,
-            projectId: prompt.projectId,
-            title: prompt.title,
-            contentPreview,
-            content: prompt.content,
-            tags: prompt.tags,
-            version: prompt.version,
-            createdAt: prompt.createdAt,
-            updatedAt: prompt.updatedAt,
-        };
-    }
-    mapSkillListItem(skill) {
-        const description = skill.shortDescription ||
-            (skill.description ? skill.description.slice(0, 120) : 'No description available');
-        return {
-            slug: skill.slug,
-            description,
-        };
-    }
-    mapSkillDetail(skill) {
-        return {
-            slug: skill.slug,
-            name: skill.name,
-            description: skill.description,
-            instructionContent: skill.instructionContent,
-            contentPath: skill.contentPath,
-            resources: skill.resources,
-            sourceUrl: skill.sourceUrl,
-            license: skill.license,
-            compatibility: skill.compatibility,
-            status: skill.status,
-            frontmatter: skill.frontmatter,
-        };
-    }
-    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({ projectId: null });
-        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.mapPromptDetail(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, '');
-    }
-    async listReviews(params) {
-        const validated = mcp_dto_1.ListReviewsParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!this.reviewsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'ReviewsService is not available',
-                },
-            };
-        }
-        const result = await this.reviewsService.listReviews(project.id, {
-            status: validated.status,
-            epicId: validated.epicId,
-            limit: validated.limit ?? 100,
-            offset: validated.offset ?? 0,
-        });
-        const reviews = result.items.map((review) => ({
-            id: review.id,
-            title: review.title,
-            description: review.description,
-            status: review.status,
-            baseRef: review.baseRef,
-            headRef: review.headRef,
-            baseSha: review.baseSha,
-            headSha: review.headSha,
-            epicId: review.epicId,
-            createdBy: review.createdBy,
-            createdByAgentId: review.createdByAgentId,
-            version: review.version,
-            commentCount: review.commentCount,
-            createdAt: review.createdAt,
-            updatedAt: review.updatedAt,
-        }));
-        const response = {
-            reviews,
-            total: result.total,
-            limit: result.limit,
-            offset: result.offset,
-        };
-        return { success: true, data: response };
-    }
-    async getReview(params) {
-        const validated = mcp_dto_1.GetReviewParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!this.reviewsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'ReviewsService is not available',
-                },
-            };
-        }
-        try {
-            const reviewWithFiles = await this.reviewsService.getReview(validated.reviewId);
-            if (reviewWithFiles.projectId !== project.id) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'REVIEW_NOT_FOUND',
-                        message: `Review ${validated.reviewId} does not belong to this project`,
-                    },
-                };
-            }
-            const commentsResult = await this.reviewsService.listComments(validated.reviewId, {
-                limit: 500,
-            });
-            const agentIds = new Set();
-            for (const comment of commentsResult.items) {
-                if (comment.authorAgentId)
-                    agentIds.add(comment.authorAgentId);
-            }
-            const agentNameById = new Map();
-            for (const agentId of agentIds) {
-                try {
-                    const agent = await this.storage.getAgent(agentId);
-                    agentNameById.set(agentId, agent.name);
-                }
-                catch {
-                }
-            }
-            const comments = commentsResult.items.map((comment) => ({
-                id: comment.id,
-                filePath: comment.filePath,
-                lineStart: comment.lineStart,
-                lineEnd: comment.lineEnd,
-                side: comment.side,
-                content: comment.content,
-                commentType: comment.commentType,
-                status: comment.status,
-                authorType: comment.authorType,
-                authorAgentId: comment.authorAgentId,
-                authorAgentName: comment.authorAgentId
-                    ? agentNameById.get(comment.authorAgentId)
-                    : undefined,
-                parentId: comment.parentId,
-                version: comment.version,
-                createdAt: comment.createdAt,
-                updatedAt: comment.updatedAt,
-            }));
-            const changedFiles = (reviewWithFiles.changedFiles ?? []).map((file) => ({
-                path: file.path,
-                status: file.status,
-                additions: file.additions,
-                deletions: file.deletions,
-                oldPath: file.oldPath,
-            }));
-            const response = {
-                review: {
-                    id: reviewWithFiles.id,
-                    title: reviewWithFiles.title,
-                    description: reviewWithFiles.description,
-                    status: reviewWithFiles.status,
-                    baseRef: reviewWithFiles.baseRef,
-                    headRef: reviewWithFiles.headRef,
-                    baseSha: reviewWithFiles.baseSha,
-                    headSha: reviewWithFiles.headSha,
-                    epicId: reviewWithFiles.epicId,
-                    createdBy: reviewWithFiles.createdBy,
-                    createdByAgentId: reviewWithFiles.createdByAgentId,
-                    version: reviewWithFiles.version,
-                    createdAt: reviewWithFiles.createdAt,
-                    updatedAt: reviewWithFiles.updatedAt,
-                },
-                changedFiles,
-                comments,
-            };
-            return { success: true, data: response };
-        }
-        catch (error) {
-            if (error instanceof error_types_1.NotFoundError) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'REVIEW_NOT_FOUND',
-                        message: `Review ${validated.reviewId} was not found`,
-                    },
-                };
-            }
-            throw error;
-        }
-    }
-    async getReviewComments(params) {
-        const validated = mcp_dto_1.GetReviewCommentsParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!this.reviewsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'ReviewsService is not available',
-                },
-            };
-        }
-        try {
-            const review = await this.storage.getReview(validated.reviewId);
-            if (review.projectId !== project.id) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'REVIEW_NOT_FOUND',
-                        message: `Review ${validated.reviewId} does not belong to this project`,
-                    },
-                };
-            }
-            const result = await this.reviewsService.listComments(validated.reviewId, {
-                status: validated.status,
-                filePath: validated.filePath,
-                limit: validated.limit ?? 100,
-                offset: validated.offset ?? 0,
-            });
-            const agentIds = new Set();
-            for (const comment of result.items) {
-                if (comment.authorAgentId)
-                    agentIds.add(comment.authorAgentId);
-            }
-            const agentNameById = new Map();
-            for (const agentId of agentIds) {
-                try {
-                    const agent = await this.storage.getAgent(agentId);
-                    agentNameById.set(agentId, agent.name);
-                }
-                catch {
-                }
-            }
-            const comments = result.items.map((comment) => ({
-                id: comment.id,
-                filePath: comment.filePath,
-                lineStart: comment.lineStart,
-                lineEnd: comment.lineEnd,
-                side: comment.side,
-                content: comment.content,
-                commentType: comment.commentType,
-                status: comment.status,
-                authorType: comment.authorType,
-                authorAgentId: comment.authorAgentId,
-                authorAgentName: comment.authorAgentId
-                    ? agentNameById.get(comment.authorAgentId)
-                    : undefined,
-                parentId: comment.parentId,
-                version: comment.version,
-                createdAt: comment.createdAt,
-                updatedAt: comment.updatedAt,
-            }));
-            const response = {
-                comments,
-                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: 'REVIEW_NOT_FOUND',
-                        message: `Review ${validated.reviewId} was not found`,
-                    },
-                };
-            }
-            throw error;
-        }
-    }
-    async replyComment(params) {
-        const validated = mcp_dto_1.ReplyCommentParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        const actor = getActorFromContext(ctx.data);
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!this.reviewsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'ReviewsService is not available',
-                },
-            };
-        }
-        try {
-            const review = await this.storage.getReview(validated.reviewId);
-            if (review.projectId !== project.id) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'REVIEW_NOT_FOUND',
-                        message: `Review ${validated.reviewId} does not belong to this project`,
-                    },
-                };
-            }
-            const comment = await this.reviewsService.createComment(validated.reviewId, {
-                parentId: validated.parentCommentId,
-                content: validated.content,
-                filePath: validated.filePath,
-                lineStart: validated.lineStart,
-                lineEnd: validated.lineEnd,
-                commentType: validated.commentType ?? 'comment',
-                authorType: 'agent',
-                authorAgentId: actor?.id,
-                targetAgentIds: validated.targetAgentIds,
-            });
-            const response = {
-                comment: {
-                    id: comment.id,
-                    filePath: comment.filePath,
-                    lineStart: comment.lineStart,
-                    lineEnd: comment.lineEnd,
-                    side: comment.side,
-                    content: comment.content,
-                    commentType: comment.commentType,
-                    status: comment.status,
-                    authorType: comment.authorType,
-                    authorAgentId: comment.authorAgentId,
-                    authorAgentName: actor?.name,
-                    parentId: comment.parentId,
-                    version: comment.version,
-                    createdAt: comment.createdAt,
-                    updatedAt: comment.updatedAt,
-                },
-            };
-            return { success: true, data: response };
-        }
-        catch (error) {
-            if (error instanceof error_types_1.NotFoundError) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'REVIEW_NOT_FOUND',
-                        message: `Review ${validated.reviewId} was not found`,
-                    },
-                };
-            }
-            throw error;
-        }
-    }
-    async resolveComment(params) {
-        const validated = mcp_dto_1.ResolveCommentParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!this.reviewsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'ReviewsService is not available',
-                },
-            };
-        }
-        try {
-            const comment = await this.storage.getReviewComment(validated.commentId);
-            const review = await this.storage.getReview(comment.reviewId);
-            if (review.projectId !== project.id) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'COMMENT_NOT_FOUND',
-                        message: `Comment ${validated.commentId} does not belong to this project`,
-                    },
-                };
-            }
-            const updatedComment = await this.reviewsService.resolveComment(comment.reviewId, validated.commentId, validated.resolution, validated.version);
-            let authorAgentName;
-            if (updatedComment.authorAgentId) {
-                try {
-                    const agent = await this.storage.getAgent(updatedComment.authorAgentId);
-                    authorAgentName = agent.name;
-                }
-                catch {
-                }
-            }
-            const response = {
-                comment: {
-                    id: updatedComment.id,
-                    filePath: updatedComment.filePath,
-                    lineStart: updatedComment.lineStart,
-                    lineEnd: updatedComment.lineEnd,
-                    side: updatedComment.side,
-                    content: updatedComment.content,
-                    commentType: updatedComment.commentType,
-                    status: updatedComment.status,
-                    authorType: updatedComment.authorType,
-                    authorAgentId: updatedComment.authorAgentId,
-                    authorAgentName,
-                    parentId: updatedComment.parentId,
-                    version: updatedComment.version,
-                    createdAt: updatedComment.createdAt,
-                    updatedAt: updatedComment.updatedAt,
-                },
-            };
-            return { success: true, data: response };
-        }
-        catch (error) {
-            if (error instanceof error_types_1.NotFoundError) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'COMMENT_NOT_FOUND',
-                        message: `Comment ${validated.commentId} was not found`,
-                    },
-                };
-            }
-            throw error;
-        }
-    }
-    async applySuggestion(params) {
-        const validated = mcp_dto_1.ApplySuggestionParamsSchema.parse(params);
-        const ctx = await this.resolveSessionContext(validated.sessionId);
-        if (!ctx.success)
-            return ctx;
-        const { project } = ctx.data;
-        if (!project) {
-            return {
-                success: false,
-                error: {
-                    code: 'PROJECT_NOT_FOUND',
-                    message: 'No project associated with this session',
-                },
-            };
-        }
-        if (!this.reviewsService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'ReviewsService is not available',
-                },
-            };
-        }
-        try {
-            const comment = await this.storage.getReviewComment(validated.commentId);
-            const review = await this.storage.getReview(comment.reviewId);
-            if (review.projectId !== project.id) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'COMMENT_NOT_FOUND',
-                        message: `Comment ${validated.commentId} does not belong to this project`,
-                    },
-                };
-            }
-            if (!comment.filePath || comment.lineStart === null) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'INVALID_SUGGESTION',
-                        message: 'Comment does not have file path or line information',
-                    },
-                };
-            }
-            const suggestionMatch = comment.content.match(/```suggestion\s*\n([\s\S]*?)```/);
-            if (!suggestionMatch) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'NO_SUGGESTION',
-                        message: 'Comment does not contain a suggestion block',
-                    },
-                };
-            }
-            const suggestedCode = suggestionMatch[1].trimEnd();
-            const lineStart = comment.lineStart;
-            const lineEnd = comment.lineEnd ?? comment.lineStart;
-            let validatedPath;
-            try {
-                validatedPath = (0, path_validation_1.validatePathWithinRoot)(project.rootPath, comment.filePath, {
-                    errorPrefix: 'Invalid file path in comment',
-                });
-            }
-            catch (error) {
-                if (error instanceof error_types_1.ValidationError) {
-                    return {
-                        success: false,
-                        error: {
-                            code: 'PATH_TRAVERSAL_BLOCKED',
-                            message: error.message,
-                            data: error.details,
-                        },
-                    };
-                }
-                throw error;
-            }
-            let realFilePath;
-            try {
-                realFilePath = await (0, path_validation_1.validateResolvedPathWithinRoot)(validatedPath.absolutePath, project.rootPath, { errorPrefix: 'Symlink validation failed' });
-            }
-            catch (error) {
-                if (error instanceof error_types_1.ValidationError) {
-                    return {
-                        success: false,
-                        error: {
-                            code: 'SYMLINK_ESCAPE_BLOCKED',
-                            message: error.message,
-                            data: error.details,
-                        },
-                    };
-                }
-                throw error;
-            }
-            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-            const filePath = realFilePath;
-            const fileContent = await fs.readFile(filePath, 'utf-8');
-            const lines = fileContent.split('\n');
-            try {
-                (0, path_validation_1.validateLineBounds)(lineStart, lineEnd, lines.length);
-            }
-            catch (error) {
-                if (error instanceof error_types_1.ValidationError) {
-                    return {
-                        success: false,
-                        error: {
-                            code: 'INVALID_LINE_BOUNDS',
-                            message: error.message,
-                            data: error.details,
-                        },
-                    };
-                }
-                throw error;
-            }
-            const suggestedLines = suggestedCode.split('\n');
-            lines.splice(lineStart - 1, lineEnd - lineStart + 1, ...suggestedLines);
-            await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
-            const updatedComment = await this.reviewsService.resolveComment(comment.reviewId, validated.commentId, 'resolved', validated.version);
-            let authorAgentName;
-            if (updatedComment.authorAgentId) {
-                try {
-                    const agent = await this.storage.getAgent(updatedComment.authorAgentId);
-                    authorAgentName = agent.name;
-                }
-                catch {
-                }
-            }
-            const response = {
-                comment: {
-                    id: updatedComment.id,
-                    filePath: updatedComment.filePath,
-                    lineStart: updatedComment.lineStart,
-                    lineEnd: updatedComment.lineEnd,
-                    side: updatedComment.side,
-                    content: updatedComment.content,
-                    commentType: updatedComment.commentType,
-                    status: updatedComment.status,
-                    authorType: updatedComment.authorType,
-                    authorAgentId: updatedComment.authorAgentId,
-                    authorAgentName,
-                    parentId: updatedComment.parentId,
-                    version: updatedComment.version,
-                    createdAt: updatedComment.createdAt,
-                    updatedAt: updatedComment.updatedAt,
-                },
-                applied: {
-                    filePath: comment.filePath,
-                    lineStart,
-                    lineEnd,
-                    suggestedCode,
-                },
-            };
-            return { success: true, data: response };
-        }
-        catch (error) {
-            if (error instanceof error_types_1.NotFoundError) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'COMMENT_NOT_FOUND',
-                        message: `Comment ${validated.commentId} was not found`,
-                    },
-                };
-            }
-            if (error.code === 'ENOENT') {
-                return {
-                    success: false,
-                    error: {
-                        code: 'FILE_NOT_FOUND',
-                        message: `File not found at path`,
-                    },
-                };
-            }
-            throw error;
-        }
+    async resolveSessionContext(sessionId) {
+        return this.sessionContextResolver.resolve(sessionId);
     }
 };
 exports.McpService = McpService;