devchain-cli 0.2.1 → 0.3.1

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

@@ -20,13 +20,26 @@ const sessions_service_1 = require("../../sessions/services/sessions.service");
 const terminal_gateway_1 = require("../../terminal/gateways/terminal.gateway");
 const epics_service_1 = require("../../epics/services/epics.service");
 const logger_1 = require("../../../common/logging/logger");
-const path_1 = require("path");
 const mcp_dto_1 = require("../dtos/mcp.dto");
 const instructions_resolver_1 = require("./instructions-resolver");
 const error_types_1 = require("../../../common/errors/error-types");
 const common_2 = require("@nestjs/common");
 const zod_1 = require("zod");
 const logger = (0, logger_1.createLogger)('McpService');
+function redactSessionId(sessionId) {
+    if (!sessionId)
+        return '(none)';
+    return sessionId.slice(0, 4) + '****';
+}
+function redactParams(params) {
+    if (!params || typeof params !== 'object')
+        return params;
+    const obj = params;
+    if ('sessionId' in obj && typeof obj.sessionId === 'string') {
+        return { ...obj, sessionId: redactSessionId(obj.sessionId) };
+    }
+    return params;
+}
 let McpService = class McpService {
     constructor(storage, chatService, sessionsService, terminalGateway, epicsService) {
         this.storage = storage;
@@ -65,52 +78,10 @@ let McpService = class McpService {
         }
         return { id: matches[0].id, name: matches[0].name };
     }
-    validateAbsolutePath(pathValue) {
-        if (!pathValue) {
-            return {
-                success: false,
-                error: {
-                    code: 'INVALID_PATH',
-                    message: 'Path parameter is required and cannot be empty.',
-                },
-            };
-        }
-        if (!(0, path_1.isAbsolute)(pathValue)) {
-            return {
-                success: false,
-                error: {
-                    code: 'INVALID_PATH',
-                    message: 'Path must be an absolute filesystem path. Please provide the full project root path (e.g., /home/user/project).',
-                },
-            };
-        }
-        return null;
-    }
-    async resolveProject(pathValue) {
-        const pathValidation = this.validateAbsolutePath(pathValue);
-        if (pathValidation) {
-            return { error: pathValidation };
-        }
-        const project = await this.storage.findProjectByPath(pathValue);
-        if (!project) {
-            logger.debug('No project found for provided path');
-            return {
-                error: {
-                    success: false,
-                    error: {
-                        code: 'PROJECT_NOT_FOUND',
-                        message: 'No project found for provided path',
-                    },
-                },
-            };
-        }
-        logger.debug({ projectId: project.id }, 'Resolved path to project');
-        return { project };
-    }
     async handleToolCall(tool, params) {
         try {
             const normalizedTool = tool.replace(/[.\-/]/g, '_');
-            logger.info({ tool: normalizedTool, originalTool: tool, params }, 'Handling MCP tool call');
+            logger.info({ tool: normalizedTool, originalTool: tool, params: redactParams(params) }, 'Handling MCP tool call');
             switch (normalizedTool) {
                 case 'devchain_create_record':
                     return await this.createRecord(params);
@@ -168,6 +139,8 @@ let McpService = class McpService {
                     return await this.activityStart(params);
                 case 'devchain_activity_finish':
                     return await this.activityFinish(params);
+                case 'devchain_list_sessions':
+                    return await this.listSessions();
                 default:
                     logger.warn({ tool: normalizedTool }, 'Unknown MCP tool');
                     return {
@@ -336,24 +309,20 @@ let McpService = class McpService {
     }
     async listDocuments(params) {
         const validated = mcp_dto_1.ListDocumentsParamsSchema.parse(params);
-        const pathValidation = this.validateAbsolutePath(validated.path);
-        if (pathValidation) {
-            return pathValidation;
-        }
-        const project = await this.storage.findProjectByPath(validated.path);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
         if (!project) {
-            logger.debug({ path: validated.path }, 'No project found for path, returning empty results');
             return {
-                success: true,
-                data: {
-                    documents: [],
-                    total: 0,
-                    limit: validated.limit ?? 100,
-                    offset: validated.offset ?? 0,
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
                 },
             };
         }
-        logger.debug({ path: validated.path, projectId: project.id }, 'Resolved path to project');
+        logger.debug({ sessionId: redactSessionId(validated.sessionId), projectId: project.id }, 'Resolved session to project');
         const filters = {
             projectId: project.id,
         };
@@ -407,21 +376,20 @@ let McpService = class McpService {
     }
     async createDocument(params) {
         const validated = mcp_dto_1.CreateDocumentParamsSchema.parse(params);
-        const pathValidation = this.validateAbsolutePath(validated.path);
-        if (pathValidation) {
-            return pathValidation;
-        }
-        const project = await this.storage.findProjectByPath(validated.path);
+        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 found for path: ${validated.path}`,
+                    message: 'No project associated with this session',
                 },
             };
         }
-        logger.debug({ path: validated.path, projectId: project.id }, 'Resolved path to project for document creation');
+        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,
@@ -450,39 +418,28 @@ let McpService = class McpService {
     }
     async listPrompts(params) {
         const validated = mcp_dto_1.ListPromptsParamsSchema.parse(params);
-        let projectId;
-        if (validated.path) {
-            const pathCheck = this.validateAbsolutePath(validated.path);
-            if (pathCheck) {
-                return pathCheck;
-            }
-            const project = await this.storage.findProjectByPath(validated.path);
-            if (!project) {
-                logger.debug({ path: validated.path }, 'No project found for path; returning empty prompts');
-                return { success: true, data: { prompts: [], total: 0 } };
-            }
-            projectId = project.id;
-        }
-        else if (validated.projectId) {
-            projectId = validated.projectId;
-            logger.warn('ListPrompts called with deprecated projectId parameter; prefer path');
-        }
-        else {
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
+        if (!project) {
             return {
                 success: false,
-                error: { code: 'INVALID_PARAMS', message: 'path is required for devchain_list_prompts' },
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
             };
         }
-        const result = await this.storage.listPrompts(projectId ?? null, undefined);
+        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)));
         }
-        if (validated.q) {
-            const query = validated.q.toLowerCase();
-            items = items.filter((prompt) => prompt.title.toLowerCase().includes(query) ||
-                prompt.content.toLowerCase().includes(query));
-        }
         const response = {
             prompts: items.map((prompt) => this.mapPromptSummary(prompt)),
             total: items.length,
@@ -496,35 +453,28 @@ let McpService = class McpService {
             prompt = await this.storage.getPrompt(validated.id);
         }
         else if (validated.name) {
-            let projectId;
-            if (validated.path) {
-                const pathCheck = this.validateAbsolutePath(validated.path);
-                if (pathCheck)
-                    return pathCheck;
-                const project = await this.storage.findProjectByPath(validated.path);
-                if (!project) {
-                    return {
-                        success: false,
-                        error: { code: 'PROJECT_NOT_FOUND', message: 'No project found for provided path' },
-                    };
-                }
-                projectId = project.id;
-            }
-            else if (validated.projectId) {
-                projectId = validated.projectId;
-                logger.warn('GetPrompt called with deprecated projectId parameter; prefer path');
-            }
-            else {
+            if (!validated.sessionId) {
                 return {
                     success: false,
                     error: {
                         code: 'INVALID_PARAMS',
-                        message: 'path is required when querying prompt by name',
+                        message: 'sessionId is required when querying prompt by name',
                     },
                 };
             }
-            const list = await this.storage.listPrompts(projectId ?? null, undefined);
-            prompt = list.items.find((item) => {
+            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;
                 }
@@ -533,34 +483,38 @@ let McpService = class McpService {
                 }
                 return true;
             });
-            if (prompt) {
-                prompt = await this.storage.getPrompt(prompt.id);
+            if (found) {
+                prompt = await this.storage.getPrompt(found.id);
             }
         }
         if (!prompt) {
-            throw new Error('Prompt not found');
+            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.mapPromptSummary(prompt),
+            prompt: this.mapPromptDetail(prompt),
         };
         return { success: true, data: response };
     }
     async listAgents(params) {
         const validated = mcp_dto_1.ListAgentsParamsSchema.parse(params);
-        const pathValidation = this.validateAbsolutePath(validated.path);
-        if (pathValidation) {
-            return pathValidation;
-        }
-        const project = await this.storage.findProjectByPath(validated.path);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
         if (!project) {
-            logger.debug({ path: validated.path }, 'No project found for path, returning empty agent list');
             return {
-                success: true,
-                data: {
-                    agents: [],
-                    total: 0,
-                    limit: validated.limit ?? 100,
-                    offset: validated.offset ?? 0,
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
                 },
             };
         }
@@ -589,17 +543,16 @@ let McpService = class McpService {
     }
     async getAgentByName(params) {
         const validated = mcp_dto_1.GetAgentByNameParamsSchema.parse(params);
-        const pathValidation = this.validateAbsolutePath(validated.path);
-        if (pathValidation) {
-            return pathValidation;
-        }
-        const project = await this.storage.findProjectByPath(validated.path);
+        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 found for path: ${validated.path}`,
+                    message: 'No project associated with this session',
                 },
             };
         }
@@ -666,11 +619,20 @@ let McpService = class McpService {
     }
     async listStatuses(params) {
         const validated = mcp_dto_1.ListStatusesParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        const 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(resolution.project.id, {
+        const result = await this.storage.listStatuses(project.id, {
             limit: 1000,
             offset: 0,
         });
@@ -681,11 +643,19 @@ let McpService = class McpService {
     }
     async listEpics(params) {
         const validated = mcp_dto_1.ListEpicsParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        const 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 project = resolution.project;
         let statusId;
         if (validated.statusName) {
             const status = await this.storage.findStatusByName(project.id, validated.statusName);
@@ -708,6 +678,8 @@ let McpService = class McpService {
             q: query && query.length ? query : undefined,
             limit,
             offset,
+            excludeMcpHidden: true,
+            parentOnly: true,
         });
         const statusesResult = await this.storage.listStatuses(project.id, {
             limit: 1000,
@@ -731,12 +703,27 @@ let McpService = class McpService {
                 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 = {
@@ -749,11 +736,19 @@ let McpService = class McpService {
     }
     async listAssignedEpicsTasks(params) {
         const validated = mcp_dto_1.ListAssignedEpicsTasksParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        const 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 project = resolution.project;
         const limit = validated.limit ?? 100;
         const offset = validated.offset ?? 0;
         try {
@@ -761,6 +756,7 @@ let McpService = class McpService {
                 agentName: validated.agentName,
                 limit,
                 offset,
+                excludeMcpHidden: true,
             });
             const statusesResult = await this.storage.listStatuses(project.id, {
                 limit: 1000,
@@ -834,11 +830,19 @@ let McpService = class McpService {
             };
         }
         const validated = mcp_dto_1.CreateEpicParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        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 project = resolution.project;
         let statusId;
         if (validated.statusName) {
             const status = await this.storage.findStatusByName(project.id, validated.statusName);
@@ -910,11 +914,19 @@ let McpService = class McpService {
     }
     async getEpicById(params) {
         const validated = mcp_dto_1.GetEpicByIdParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        const 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 project = resolution.project;
         let epic;
         try {
             epic = await this.storage.getEpic(validated.id);
@@ -1013,11 +1025,28 @@ let McpService = class McpService {
     }
     async addEpicComment(params) {
         const validated = mcp_dto_1.AddEpicCommentParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { agent: authorAgent, project } = ctx.data;
+        if (!authorAgent) {
+            return {
+                success: false,
+                error: {
+                    code: 'AGENT_REQUIRED',
+                    message: 'Session must be associated with an agent to add comments',
+                },
+            };
+        }
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
         }
-        const project = resolution.project;
         let epic;
         try {
             epic = await this.storage.getEpic(validated.epicId);
@@ -1045,7 +1074,7 @@ let McpService = class McpService {
         }
         const comment = await this.storage.createEpicComment({
             epicId: validated.epicId,
-            authorName: validated.authorName,
+            authorName: authorAgent.name,
             content: validated.content,
         });
         const response = {
@@ -1075,11 +1104,19 @@ let McpService = class McpService {
             }
         }
         const validated = mcp_dto_1.UpdateEpicParamsSchema.parse(preprocessedParams);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        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 project = resolution.project;
         let epic;
         try {
             epic = await this.storage.getEpic(validated.id);
@@ -1261,7 +1298,7 @@ let McpService = class McpService {
         return { success: true, data: response };
     }
     async sendMessage(params) {
-        if (!this.chatService || !this.sessionsService) {
+        if (!this.sessionsService) {
             return {
                 success: false,
                 error: {
@@ -1271,23 +1308,33 @@ let McpService = class McpService {
             };
         }
         const validated = mcp_dto_1.SendMessageParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project) {
-            return resolution.error;
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { agent: senderAgent, project } = ctx.data;
+        if (!senderAgent) {
+            return {
+                success: false,
+                error: {
+                    code: 'AGENT_REQUIRED',
+                    message: 'Session must be associated with an agent to send messages',
+                },
+            };
+        }
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
         }
-        const project = resolution.project;
         try {
-            let senderAgentId = null;
-            const validatedWithRecipient = validated;
-            const recipientType = validatedWithRecipient.recipient ?? 'agents';
-            const senderNameInput = validated.senderName ?? validatedWithRecipient.agentName;
-            if (senderNameInput) {
-                const resolved = await this.resolveAgentByNameUnique(project.id, senderNameInput);
-                if (!('id' in resolved)) {
-                    return resolved;
-                }
-                senderAgentId = resolved.id;
-            }
+            const autoLaunchSessions = process.env.NODE_ENV !== 'test';
+            const senderAgentId = senderAgent.id;
+            const senderAgentName = senderAgent.name;
+            const recipientType = validated.recipient ?? 'agents';
             let normalizedRecipientIds = [];
             if (validated.recipientAgentNames && validated.recipientAgentNames.length > 0) {
                 for (const name of validated.recipientAgentNames) {
@@ -1296,6 +1343,60 @@ let McpService = class McpService {
                 }
             }
             normalizedRecipientIds = Array.from(new Set(normalizedRecipientIds.filter((id) => id && id !== senderAgentId)));
+            if (!validated.threadId && senderAgentId && recipientType !== 'user') {
+                if (normalizedRecipientIds.length === 0) {
+                    return {
+                        success: false,
+                        error: {
+                            code: 'RECIPIENTS_REQUIRED',
+                            message: 'Recipient agents must be provided when sending agent-to-agent without threadId.',
+                        },
+                    };
+                }
+                const activeSessions = await this.sessionsService.listActiveSessions();
+                const delivered = [];
+                for (const agentId of normalizedRecipientIds) {
+                    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,
+                            });
+                            session = launched;
+                            activeSessions.push(launched);
+                        }
+                        catch {
+                        }
+                    }
+                    if (!session) {
+                        delivered.push({ agentName: agent.name, status: 'queued' });
+                        continue;
+                    }
+                    const injectionText = `\n[This message is sent from "${senderAgentName}" agent use devchain_send_message tool for communication]\n${validated.message}\n`;
+                    await this.sessionsService.injectTextIntoSession(session.id, injectionText);
+                    delivered.push({
+                        agentName: agent.name,
+                        status: 'delivered',
+                    });
+                }
+                const response = {
+                    mode: 'direct_injection',
+                    deliveryCount: delivered.filter((d) => d.status === 'delivered').length,
+                    delivered,
+                };
+                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 && senderAgentId) {
                 if (recipientType === 'user') {
@@ -1306,23 +1407,6 @@ let McpService = class McpService {
                     threadId = direct.id;
                 }
                 else {
-                    const recips = normalizedRecipientIds;
-                    if (recips.length === 0) {
-                        return {
-                            success: false,
-                            error: {
-                                code: 'RECIPIENTS_REQUIRED',
-                                message: 'Recipient agents must be provided when creating a new thread without threadId.',
-                            },
-                        };
-                    }
-                    const groupThread = await this.chatService.createGroupThread({
-                        projectId: project.id,
-                        agentIds: Array.from(new Set([senderAgentId, ...recips])),
-                        createdByType: 'agent',
-                        createdByAgentId: senderAgentId,
-                    });
-                    threadId = groupThread.id;
                 }
             }
             if (!threadId) {
@@ -1330,14 +1414,14 @@ let McpService = class McpService {
                     success: false,
                     error: {
                         code: 'THREAD_REQUIRED',
-                        message: 'threadId is required when senderName is not provided',
+                        message: 'Unable to determine thread for message delivery',
                     },
                 };
             }
             const thread = await this.chatService.getThread(threadId);
             const message = await this.chatService.createMessage(threadId, {
-                authorType: senderAgentId ? 'agent' : 'user',
-                authorAgentId: senderAgentId ?? undefined,
+                authorType: 'agent',
+                authorAgentId: senderAgentId,
                 content: validated.message,
             });
             let targetAgentIds = normalizedRecipientIds;
@@ -1351,30 +1435,34 @@ let McpService = class McpService {
             const delivered = [];
             for (const agentId of targetAgentIds) {
                 const agent = await this.storage.getAgent(agentId);
-                const session = activeSessions.find((s) => s.agentId === agentId);
-                if (session) {
-                    const senderName = senderAgentId
-                        ? (await this.storage.getAgent(senderAgentId)).name
-                        : 'User';
-                    const injectionText = `\n[CHAT] From: ${senderName} • Thread: ${threadId}\n${validated.message}\n[ACK] tools/call { name: "devchain_chat_ack", arguments: { thread_id: "${threadId}", message_id: "${message.id}", agent_name: "${agent.name}" } }\n`;
-                    await this.sessionsService.injectTextIntoSession(session.id, injectionText);
-                    delivered.push({
-                        agentId,
-                        agentName: agent.name,
-                        sessionId: session.id,
-                        status: 'delivered',
-                    });
+                let session = activeSessions.find((s) => s.agentId === agentId);
+                if (!session && autoLaunchSessions) {
+                    try {
+                        const launched = await this.sessionsService.launchSession({
+                            projectId: project.id,
+                            agentId,
+                        });
+                        session = launched;
+                        activeSessions.push(launched);
+                    }
+                    catch {
+                    }
                 }
-                else {
-                    delivered.push({
-                        agentId,
-                        agentName: agent.name,
-                        sessionId: '',
-                        status: 'queued',
-                    });
+                if (!session) {
+                    delivered.push({ agentId, agentName: agent.name, sessionId: '', status: 'queued' });
+                    continue;
                 }
+                const injectionText = `\n[CHAT] From: ${senderAgentName} • 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,
@@ -1383,7 +1471,7 @@ let McpService = class McpService {
             return { success: true, data: response };
         }
         catch (error) {
-            logger.error({ error, params: validated }, 'sendMessage failed');
+            logger.error({ error, params: redactParams(validated) }, 'sendMessage failed');
             return {
                 success: false,
                 error: {
@@ -1405,28 +1493,32 @@ let McpService = class McpService {
         }
         const validated = mcp_dto_1.ChatAckParamsSchema.parse(params);
         const { thread_id: threadId, message_id: messageId } = validated;
-        let agentId = null;
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { agent } = ctx.data;
+        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 ?? [];
-            let resolved = null;
-            for (const mid of memberIds) {
-                const a = await this.storage.getAgent(mid);
-                if (a.name.toLowerCase() === validated.agent_name.toLowerCase()) {
-                    resolved = a.id;
-                    break;
-                }
-            }
-            if (!resolved) {
+            if (!memberIds.includes(agentId)) {
                 return {
                     success: false,
                     error: {
                         code: 'AGENT_NOT_IN_THREAD',
-                        message: `Agent ${validated.agent_name} is not a member of thread ${threadId}`,
+                        message: `Agent ${agent.name} is not a member of thread ${threadId}`,
                     },
                 };
             }
-            agentId = resolved;
             const now = new Date().toISOString();
             await this.storage.markMessageAsRead(messageId, agentId, now);
             if (this.sessionsService) {
@@ -1438,28 +1530,20 @@ let McpService = class McpService {
             }
             this.terminalGateway.broadcastEvent(`chat/${threadId}`, 'message.read', {
                 messageId,
-                agentId: agentId,
+                agentId,
                 readAt: now,
             });
-            let agentName = validated.agent_name ?? '';
-            if (!agentName) {
-                try {
-                    const a = await this.storage.getAgent(agentId);
-                    agentName = a.name;
-                }
-                catch { }
-            }
             const response = {
                 threadId,
                 messageId,
-                agentId: agentId,
-                agentName,
+                agentId,
+                agentName: agent.name,
                 acknowledged: true,
             };
             return { success: true, data: response };
         }
         catch (error) {
-            logger.error({ error, params: validated }, 'chatAck failed');
+            logger.error({ error, params: redactParams(validated) }, 'chatAck failed');
             return {
                 success: false,
                 error: {
@@ -1643,14 +1727,29 @@ let McpService = class McpService {
             };
         }
         const validated = mcp_dto_1.ActivityStartParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project)
-            return resolution.error;
-        const project = resolution.project;
-        const agentRes = await this.resolveAgentByNameUnique(project.id, validated.agentName);
-        if (!('id' in agentRes))
-            return agentRes;
-        const agentId = agentRes.id;
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project, agent } = ctx.data;
+        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);
@@ -1660,7 +1759,7 @@ let McpService = class McpService {
                     success: false,
                     error: {
                         code: 'AGENT_NOT_IN_THREAD',
-                        message: `Agent ${validated.agentName} is not a member of thread ${threadId}`,
+                        message: `Agent ${agent.name} is not a member of thread ${threadId}`,
                     },
                 };
             }
@@ -1689,14 +1788,29 @@ let McpService = class McpService {
             };
         }
         const validated = mcp_dto_1.ActivityFinishParamsSchema.parse(params);
-        const resolution = await this.resolveProject(validated.path);
-        if (!resolution.project)
-            return resolution.error;
-        const project = resolution.project;
-        const agentRes = await this.resolveAgentByNameUnique(project.id, validated.agentName);
-        if (!('id' in agentRes))
-            return agentRes;
-        const agentId = agentRes.id;
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project, agent } = ctx.data;
+        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);
@@ -1706,7 +1820,7 @@ let McpService = class McpService {
                     success: false,
                     error: {
                         code: 'AGENT_NOT_IN_THREAD',
-                        message: `Agent ${validated.agentName} is not a member of thread ${threadId}`,
+                        message: `Agent ${agent.name} is not a member of thread ${threadId}`,
                     },
                 };
             }
@@ -1740,6 +1854,160 @@ let McpService = class McpService {
             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) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'SESSION_NOT_FOUND',
+                        message: `No active session 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 = {
+                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',
+                },
+            };
+        }
+    }
     mapStatusSummary(status) {
         return {
             id: status.id,
@@ -1765,6 +2033,7 @@ let McpService = class McpService {
         if (epic.parentId) {
             summary.parentId = epic.parentId;
         }
+        summary.tags = epic.tags ?? [];
         return summary;
     }
     mapEpicChild(epic) {
@@ -1814,6 +2083,23 @@ let McpService = class McpService {
             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,
@@ -2004,7 +2290,7 @@ let McpService = class McpService {
                 throw new Error(`Invalid prompt version in URI: ${uri}`);
             }
         }
-        const list = await this.storage.listPrompts(null, undefined);
+        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) {
@@ -2023,7 +2309,7 @@ let McpService = class McpService {
                 uri,
                 mimeType: 'text/markdown',
                 content: prompt.content,
-                prompt: this.mapPromptSummary(prompt),
+                prompt: this.mapPromptDetail(prompt),
             },
         };
     }