crewx 0.8.8-rc.2 → 0.8.8-rc.21

package/dist-server/domain/mcp/mcp.service.js

@@ -16,6 +16,8 @@ const mcp_dto_js_1 = require("./mcp.dto.js");
 const crewx_tool_factory_js_1 = require("./crewx-tool.factory.js");
 const browser_session_store_js_1 = require("./browser-session.store.js");
 const tool_router_service_js_1 = require("./tool-router.service.js");
+const chromex_negotiate_service_js_1 = require("./chromex-negotiate.service.js");
+const chromex_blacklist_js_1 = require("./chromex-blacklist.js");
 const crewx_pool_service_js_1 = require("../../modules/crewx-pool.service.js");
 const project_repository_js_1 = require("../../repository/project.repository.js");
 const repository_1 = require("@crewx/sdk/repository");
@@ -166,14 +168,16 @@ let McpService = McpService_1 = class McpService {
     browserSessions;
     toolRouter;
     toolCallRepo;
+    negotiateService;
     logger = new common_1.Logger(McpService_1.name);
     activeTaskMap = new Map();
-    constructor(crewxPool, projectRepo, browserSessions, toolRouter, toolCallRepo) {
+    constructor(crewxPool, projectRepo, browserSessions, toolRouter, toolCallRepo, negotiateService) {
         this.crewxPool = crewxPool;
         this.projectRepo = projectRepo;
         this.browserSessions = browserSessions;
         this.toolRouter = toolRouter;
         this.toolCallRepo = toolCallRepo;
+        this.negotiateService = negotiateService;
     }
     async getToolForCurrentRequest() {
         const crewx = await this.crewxPool.getForCurrentRequest();
@@ -235,7 +239,7 @@ let McpService = McpService_1 = class McpService {
     isNotification(body) {
         return body.id === undefined || body.id === null;
     }
-    async handleRequest(body, sessionId, clientType) {
+    async handleRequest(body, sessionId, clientType, request) {
         const { method, id } = body;
         this.logger.debug(`Handling MCP method: ${method}`);
         if (this.isNotification(body)) {
@@ -255,7 +259,7 @@ let McpService = McpService_1 = class McpService {
             case 'tools/list':
                 return this.handleToolsList(id, sessionId);
             case 'tools/call':
-                return this.handleToolsCall(id, body.params, sessionId);
+                return this.handleToolsCall(id, body.params, sessionId, request);
             case 'prompts/list':
                 return {
                     jsonrpc: '2.0',
@@ -294,6 +298,13 @@ let McpService = McpService_1 = class McpService {
     getBrowserSessionStore() {
         return this.browserSessions;
     }
+    /** Push a JSON-RPC notification to the latest Chrome X browser SSE session. Returns false if no browser connected. */
+    pushToChromexSession(payload) {
+        const session = this.browserSessions.getLatestBrowserSession();
+        if (!session)
+            return false;
+        return this.browserSessions.pushNotification(session.id, payload);
+    }
     handleInitialize(id, clientType) {
         const sessionId = this.createBrowserSession(clientType);
         return {
@@ -348,7 +359,7 @@ let McpService = McpService_1 = class McpService {
         this.browserSessions.registerTools(sessionId, params.tools, params.mode);
         return null;
     }
-    async handleToolsCall(id, params, sessionId) {
+    async handleToolsCall(id, params, sessionId, request) {
         if (!params?.name) {
             return {
                 jsonrpc: '2.0',
@@ -364,7 +375,52 @@ let McpService = McpService_1 = class McpService {
         // Browser tool: route via SSE to the extension (dual routing: prefix + session lookup)
         if (this.toolRouter.isBrowserTool(params.name, sessionId)) {
             this.logger.log(`tools/call [browser]: ${params.name}`);
+            const claims = request?.tokenClaims;
+            // Browser control is only available through a negotiate token. The token's
+            // agentScope is the authority; do not trust a client-supplied agentId.
+            if (claims?.source !== 'negotiate' || !claims.agentScope) {
+                return {
+                    jsonrpc: '2.0',
+                    id: id ?? null,
+                    error: { code: -32001, message: 'Negotiate token required for browser tools' },
+                };
+            }
+            const requestedTabId = params.arguments?.['tabId'];
+            if (claims.browserScope &&
+                claims.browserScope !== 'all_tabs' &&
+                claims.browserScope.startsWith('tab:') &&
+                String(requestedTabId) !== claims.browserScope.slice(4)) {
+                return {
+                    jsonrpc: '2.0',
+                    id: id ?? null,
+                    error: { code: -32001, message: 'Browser scope denied' },
+                };
+            }
+            const nestedArgs = params.arguments?.['args'];
+            const nestedUrl = nestedArgs && typeof nestedArgs === 'object' && !Array.isArray(nestedArgs)
+                ? nestedArgs['url']
+                : undefined;
+            const tabUrl = String(params.arguments?.['tabUrl'] ?? params.arguments?.['url'] ?? nestedUrl ?? '');
+            if (tabUrl && (0, chromex_blacklist_js_1.isBlacklisted)(tabUrl)) {
+                this.negotiateService.logAudit({
+                    agentId: claims?.agentScope ?? 'unknown',
+                    action: 'tool_call_blocked',
+                    jti: claims?.jti,
+                    tabUrl,
+                    toolName: params.name,
+                    result: 'blocked',
+                });
+                return { jsonrpc: '2.0', id: id ?? null, error: { code: -32001, message: 'URL is blacklisted' } };
+            }
             response = await this.toolRouter.dispatch(sessionId, params.name, params.arguments ?? {}, id);
+            this.negotiateService.logAudit({
+                agentId: claims?.agentScope ?? 'unknown',
+                action: 'tool_call',
+                jti: claims?.jti,
+                tabUrl: tabUrl || null,
+                toolName: params.name,
+                result: 'success',
+            });
         }
         else {
             // Server tool: must exist in TOOL_DEFINITIONS
@@ -671,7 +727,8 @@ exports.McpService = McpService = McpService_1 = __decorate([
         project_repository_js_1.ProjectRepository,
         browser_session_store_js_1.BrowserSessionStore,
         tool_router_service_js_1.ToolRouterService,
-        repository_1.ToolCallRepository])
+        repository_1.ToolCallRepository,
+        chromex_negotiate_service_js_1.ChromexNegotiateService])
 ], McpService);
 function normalizeContent(result) {
     if (Array.isArray(result.content) && result.content.length > 0) {

package/dist-server/domain/message/dto/send-message.dto.js

@@ -9,14 +9,42 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendMessageDto = void 0;
+exports.SendMessageDto = exports.ImageAttachmentDto = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+class ImageAttachmentDto {
+    data;
+    mimeType;
+    filename;
+}
+exports.ImageAttachmentDto = ImageAttachmentDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, swagger_1.ApiProperty)({ description: 'Base64-encoded image data' }),
+    __metadata("design:type", String)
+], ImageAttachmentDto.prototype, "data", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, swagger_1.ApiProperty)({ description: 'MIME type (image/png, image/jpeg, image/gif, image/webp)' }),
+    __metadata("design:type", String)
+], ImageAttachmentDto.prototype, "mimeType", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, swagger_1.ApiPropertyOptional)({ description: 'Original filename' }),
+    __metadata("design:type", String)
+], ImageAttachmentDto.prototype, "filename", void 0);
 class SendMessageDto {
     message;
     agent;
     title;
     mode = 'query';
+    images;
+    context;
+    browserSessionId;
 }
 exports.SendMessageDto = SendMessageDto;
 __decorate([
@@ -43,3 +71,22 @@ __decorate([
     (0, swagger_1.ApiPropertyOptional)({ description: 'Execution mode: query (read-only, default) or execute (full permissions)', default: 'query' }),
     __metadata("design:type", String)
 ], SendMessageDto.prototype, "mode", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => ImageAttachmentDto),
+    (0, swagger_1.ApiPropertyOptional)({ description: 'Attached images (base64)', type: [ImageAttachmentDto] }),
+    __metadata("design:type", Array)
+], SendMessageDto.prototype, "images", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, swagger_1.ApiPropertyOptional)({ description: 'Provider-agnostic context prepended to the message' }),
+    __metadata("design:type", String)
+], SendMessageDto.prototype, "context", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, swagger_1.ApiPropertyOptional)({ description: 'Chrome X browser MCP session id for reverse browser-tool calls' }),
+    __metadata("design:type", String)
+], SendMessageDto.prototype, "browserSessionId", void 0);

package/dist-server/domain/message/message.controller.js

@@ -15,11 +15,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageController = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
+const path_1 = require("path");
+const fs_1 = require("fs");
 const message_service_js_1 = require("./message.service.js");
 const box_service_js_1 = require("../box/box.service.js");
 const send_message_dto_js_1 = require("./dto/send-message.dto.js");
 const list_messages_dto_js_1 = require("./dto/list-messages.dto.js");
 const workspace_decorator_js_1 = require("../../common/decorators/workspace.decorator.js");
+const workspace_context_store_js_1 = require("../../common/workspace-context.store.js");
+const EXT_MIME = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+};
 let MessageController = class MessageController {
     messageService;
     boxService;
@@ -39,9 +49,28 @@ let MessageController = class MessageController {
     }
     // MSG.SEND: Send message to thread (spawns crewx CLI in background)
     async sendMessage(threadId, body, ws) {
-        const data = await this.messageService.sendMessage(threadId, body.message, body.agent, body.mode, body.title, ws.id);
+        const data = await this.messageService.sendMessage(threadId, body.message, body.agent, body.mode, body.title, ws.id, body.images, body.context, body.browserSessionId);
         return { success: true, data };
     }
+    serveAttachment(threadId, filename, res) {
+        if (filename.includes('/') || filename.includes('..')) {
+            throw new common_1.BadRequestException('Invalid filename');
+        }
+        const wsPath = (0, workspace_context_store_js_1.getWorkspacePath)();
+        const filePath = (0, path_1.join)(wsPath, '.crewx', 'attachments', threadId, filename);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            throw new common_1.NotFoundException('Attachment not found');
+        }
+        const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+        const mime = EXT_MIME[ext] ?? 'application/octet-stream';
+        const stat = (0, fs_1.statSync)(filePath);
+        res.set({
+            'Content-Type': mime,
+            'Content-Length': stat.size,
+            'Cache-Control': 'public, max-age=31536000, immutable',
+        });
+        (0, fs_1.createReadStream)(filePath).pipe(res);
+    }
 };
 exports.MessageController = MessageController;
 __decorate([
@@ -65,6 +94,16 @@ __decorate([
     __metadata("design:paramtypes", [String, send_message_dto_js_1.SendMessageDto, Object]),
     __metadata("design:returntype", Promise)
 ], MessageController.prototype, "sendMessage", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'MSG.ATTACHMENT', summary: 'Serve thread attachment image' }),
+    (0, common_1.Get)('attachments/:filename'),
+    __param(0, (0, common_1.Param)('threadId')),
+    __param(1, (0, common_1.Param)('filename')),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", void 0)
+], MessageController.prototype, "serveAttachment", null);
 exports.MessageController = MessageController = __decorate([
     (0, swagger_1.ApiTags)('messages'),
     (0, common_1.Controller)('ws/:slug/threads/:threadId/messages'),

package/dist-server/domain/message/message.service.js

@@ -12,8 +12,12 @@ var MessageService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageService = void 0;
 const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
 const thread_service_js_1 = require("../thread/thread.service.js");
 const thread_repository_js_1 = require("../../repository/thread.repository.js");
+const sdk_1 = require("@crewx/sdk");
 const crewx_pool_service_js_1 = require("../../modules/crewx-pool.service.js");
 const workspace_context_store_js_1 = require("../../common/workspace-context.store.js");
 let MessageService = MessageService_1 = class MessageService {
@@ -56,6 +60,7 @@ let MessageService = MessageService_1 = class MessageService {
                     prompt: t.prompt
                         || (ctx.hot[i - 1]?.role === 'user' ? ctx.hot[i - 1].content : ''),
                     content: msg.content,
+                    error: t.error ?? undefined,
                     startedAt: t.startedAt,
                     completedAt: t.completedAt ?? undefined,
                     durationMs: t.durationMs ?? undefined,
@@ -97,7 +102,7 @@ let MessageService = MessageService_1 = class MessageService {
         };
     }
     // MSG.SEND: Send message — fire crewx SDK; ConversationPlugin persists threads row
-    async sendMessage(threadId, message, agent, mode = 'query', title, workspaceId) {
+    async sendMessage(threadId, message, agent, mode = 'query', title, workspaceId, images, context, browserSessionId) {
         this.validateId(threadId);
         if (!message || !message.trim()) {
             throw new common_1.BadRequestException('message is required');
@@ -115,10 +120,28 @@ let MessageService = MessageService_1 = class MessageService {
                 this.logger.warn(`updateThreadTitle skipped [thread=${threadId}]: ${err.message}`);
             }
         }
+        const savedImages = this.saveImages(threadId, images);
+        let finalMessage = message;
+        if (savedImages.length > 0) {
+            const tags = savedImages
+                .map((img) => `<crewx_image path="${img.relativePath}" mime="${img.mimeType}" />`)
+                .join('\n');
+            finalMessage = `${message}\n${tags}`;
+        }
+        const trimmedContext = context?.trim();
+        if (trimmedContext) {
+            finalMessage = `<chrome_x_context>\n${trimmedContext}\n</chrome_x_context>\n\n${finalMessage}`;
+        }
+        const taskId = (0, sdk_1.generateId)('tsk');
+        const metadata = { thread: threadId, parentTaskId: null };
+        if (browserSessionId?.trim()) {
+            metadata.browserSessionId = browserSessionId.trim();
+        }
         const sdkOptions = {
             threadId,
+            taskId,
             platform: 'cli',
-            metadata: { thread: threadId, parentTaskId: null },
+            metadata,
             cwd: (0, workspace_context_store_js_1.getWorkspacePath)(),
         };
         const crewx = await this.crewxPool.getForCurrentRequest();
@@ -133,14 +156,36 @@ let MessageService = MessageService_1 = class MessageService {
         }
         const agentRef = `@${agent}`;
         const sdkCall = mode === 'execute'
-            ? crewx.execute(agentRef, message, sdkOptions)
-            : crewx.query(agentRef, message, sdkOptions);
+            ? crewx.execute(agentRef, finalMessage, sdkOptions)
+            : crewx.query(agentRef, finalMessage, sdkOptions);
         sdkCall.catch((err) => {
             this.logger.error(`Background ${mode} failed [thread=${threadId}, agent=${agent}]: ${err.message}`, err.stack);
         });
-        return { taskId: threadId, status: 'pending', agent };
+        return { taskId, status: 'pending', agent };
     }
     // --- Private helpers ---
+    saveImages(threadId, images) {
+        if (!images?.length)
+            return [];
+        const MIME_EXT = {
+            'image/png': 'png',
+            'image/jpeg': 'jpg',
+            'image/gif': 'gif',
+            'image/webp': 'webp',
+        };
+        const wsPath = (0, workspace_context_store_js_1.getWorkspacePath)();
+        const dir = (0, path_1.join)(wsPath, '.crewx', 'attachments', threadId);
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+        return images.map((img) => {
+            const ext = MIME_EXT[img.mimeType] ?? 'bin';
+            const filename = `${(0, crypto_1.randomUUID)()}.${ext}`;
+            const filePath = (0, path_1.join)(dir, filename);
+            const buf = Buffer.from(img.data, 'base64');
+            (0, fs_1.writeFileSync)(filePath, new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+            const relativePath = `.crewx/attachments/${threadId}/${filename}`;
+            return { relativePath, mimeType: img.mimeType };
+        });
+    }
     validateId(id) {
         if (!/^[\w\p{L}\p{N}._-]+$/u.test(id)) {
             throw new common_1.BadRequestException('Invalid ID format');

package/dist-server/domain/task/task.service.js

@@ -142,18 +142,30 @@ let TaskService = TaskService_1 = class TaskService {
             if (err instanceof common_1.HttpException)
                 throw err;
         }
-        // Send SIGTERM to the process
-        try {
-            process.kill(task.pid, 'SIGTERM');
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'EPERM') {
-                throw new common_1.HttpException({ code: 'PERMISSION_DENIED', message: '프로세스 중지 권한이 없습니다' }, 403);
+        // Send SIGTERM to the process group (negative pid kills detached ACP child processes too)
+        const pid = task.pid;
+        if (pid > 0) {
+            try {
+                process.kill(-pid, 'SIGTERM');
             }
-            // ESRCH = process already gone — proceed to update DB
-            if (code !== 'ESRCH')
-                throw err;
+            catch (err) {
+                const code = err.code;
+                if (code === 'EPERM') {
+                    throw new common_1.HttpException({ code: 'PERMISSION_DENIED', message: '프로세스 중지 권한이 없습니다' }, 403);
+                }
+                // ESRCH = process already gone — proceed to update DB
+                if (code !== 'ESRCH')
+                    throw err;
+            }
+            // SIGKILL fallback: if process group is still alive after 2s, force-kill
+            setTimeout(() => {
+                try {
+                    process.kill(-pid, 'SIGKILL');
+                }
+                catch {
+                    // Process already gone — ignore
+                }
+            }, 2000);
         }
         // Conditionally update DB (race condition safe)
         this.taskRepo.markTaskFailed(taskId, '사용자에 의해 중지됨');
@@ -246,6 +258,7 @@ let TaskService = TaskService_1 = class TaskService {
             platform: data.platform,
             messages: messagesWithLogs,
             metadata: data.metadata,
+            renderedPrompt: data.rendered_prompt ?? null,
             ...tokenUsage,
         };
     }
@@ -332,6 +345,7 @@ let TaskService = TaskService_1 = class TaskService {
             durationMs: row.duration_ms ?? undefined,
             error: row.error || undefined,
             prompt: row.prompt || undefined,
+            renderedPrompt: row.rendered_prompt ?? null,
             result: row.result || undefined,
             model: row.model || undefined,
             threadId: row.thread_id || undefined,
@@ -519,13 +533,13 @@ let TaskService = TaskService_1 = class TaskService {
         }
         return undefined;
     }
-    /** Merge consecutive type=text entries into one (fixes Gemini delta streaming fragmentation) */
+    /** Merge consecutive type=text entries into one while preserving message boundaries. */
     mergeConsecutiveText(entries) {
         const merged = [];
         for (const entry of entries) {
             const prev = merged[merged.length - 1];
             if (prev && prev.type === 'text' && entry.type === 'text') {
-                prev.content = (prev.content || '') + (entry.content || '');
+                prev.content = this.joinTextEntries(prev.content || '', entry.content || '');
             }
             else {
                 merged.push({ ...entry });
@@ -533,6 +547,13 @@ let TaskService = TaskService_1 = class TaskService {
         }
         return merged;
     }
+    joinTextEntries(previous, next) {
+        if (!previous)
+            return next;
+        if (!next)
+            return previous;
+        return previous + next;
+    }
     /**
      * When ACP streaming sends an initial tool_call with empty input followed by
      * a tool_call_update with refined input, both arrive as type=tool_use with

package/dist-server/domain/thread/thread.controller.js

@@ -77,6 +77,11 @@ let ThreadController = class ThreadController {
         const data = this.threadService.getThreadTask(threadId, taskId, include, logLimit, ws.id);
         return { success: true, data };
     }
+    // TSK.RETRY: Retry a failed task — prepends dreaming context hint
+    async retryTask(threadId, taskId, ws) {
+        const data = await this.threadService.retryTask(threadId, taskId, ws.id);
+        return { success: true, data };
+    }
 };
 exports.ThreadController = ThreadController;
 __decorate([
@@ -166,6 +171,17 @@ __decorate([
     __metadata("design:paramtypes", [String, String, Object, String, Number]),
     __metadata("design:returntype", void 0)
 ], ThreadController.prototype, "getThreadTask", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'TSK.RETRY', summary: 'Retry a failed task with dreaming context hint' }),
+    (0, common_1.Post)(':threadId/tasks/:taskId/retry'),
+    (0, common_1.HttpCode)(202),
+    __param(0, (0, common_1.Param)('threadId')),
+    __param(1, (0, common_1.Param)('taskId')),
+    __param(2, (0, workspace_decorator_js_1.Workspace)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], ThreadController.prototype, "retryTask", null);
 exports.ThreadController = ThreadController = __decorate([
     (0, swagger_1.ApiTags)('threads'),
     (0, common_1.Controller)('ws/:slug/threads'),

package/dist-server/domain/thread/thread.module.js

@@ -11,11 +11,13 @@ const common_1 = require("@nestjs/common");
 const thread_controller_js_1 = require("./thread.controller.js");
 const thread_service_js_1 = require("./thread.service.js");
 const box_service_js_1 = require("../box/box.service.js");
+const crewx_module_js_1 = require("../../modules/crewx.module.js");
 let ThreadModule = class ThreadModule {
 };
 exports.ThreadModule = ThreadModule;
 exports.ThreadModule = ThreadModule = __decorate([
     (0, common_1.Module)({
+        imports: [crewx_module_js_1.CrewxModule],
         controllers: [thread_controller_js_1.ThreadController],
         providers: [thread_service_js_1.ThreadService, box_service_js_1.BoxService],
         exports: [thread_service_js_1.ThreadService],

package/dist-server/domain/thread/thread.service.js

@@ -8,16 +8,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var ThreadService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadService = void 0;
 const common_1 = require("@nestjs/common");
 const tokenizer_js_1 = require("../../utils/tokenizer.js");
 const sdk_1 = require("@crewx/sdk");
 const thread_repository_js_1 = require("../../repository/thread.repository.js");
-let ThreadService = class ThreadService {
+const crewx_pool_service_js_1 = require("../../modules/crewx-pool.service.js");
+const workspace_context_store_js_1 = require("../../common/workspace-context.store.js");
+let ThreadService = ThreadService_1 = class ThreadService {
     threadRepo;
-    constructor(threadRepo) {
+    crewxPool;
+    logger = new common_1.Logger(ThreadService_1.name);
+    constructor(threadRepo, crewxPool) {
         this.threadRepo = threadRepo;
+        this.crewxPool = crewxPool;
     }
     // THD.LIST: List threads from threads table (with optional q search)
     listThreads(params, workspaceId) {
@@ -189,11 +195,11 @@ let ThreadService = class ThreadService {
             callerAgentId: row.caller_agent_id || undefined,
         };
         if (wantLogs) {
-            result.logs = this.parseLogs(row.logs, limit);
+            result.logs = this.parseLogs(row.logs, limit, this.extractAdapterKey(row));
         }
         if (wantChildren && children) {
             result.childTasks = children.map((child) => {
-                const logs = this.parseLogs(child.logs, 1);
+                const logs = this.parseLogs(child.logs, 1, this.extractAdapterKey(child));
                 return {
                     taskId: child.id,
                     agentId: child.agent_id || '',
@@ -215,6 +221,42 @@ let ThreadService = class ThreadService {
         return (0, sdk_1.buildContext)(threadId, this, // ThreadService satisfies ITaskReader
         boxService, params, tiktokenTokenizer);
     }
+    // TSK.RETRY: Retry a failed task with dreaming context hint prepended
+    async retryTask(threadId, taskId, workspaceId) {
+        this.validateId(threadId);
+        this.validateId(taskId);
+        const found = this.threadRepo.findTaskById(threadId, taskId, workspaceId);
+        if (!found) {
+            throw new common_1.NotFoundException(`Task not found: ${taskId} in thread: ${threadId}`);
+        }
+        const { task } = found;
+        if (task.status !== 'failed') {
+            throw new common_1.BadRequestException(`Task ${taskId} is not in failed state (current: ${task.status}). Only failed tasks can be retried.`);
+        }
+        const dreamingPrefix = `<crewx_system_message>\n` +
+            `Retrying a failed task.\n` +
+            `You must run \`crewx dreaming --task=${taskId}\` to review where it stopped before continuing.\n` +
+            `</crewx_system_message>\n\n`;
+        const retryPrompt = `${dreamingPrefix}${task.prompt ?? ''}`;
+        const newTaskId = (0, sdk_1.generateId)('tsk');
+        const agentRef = `@${task.agent_id}`;
+        const mode = task.mode ?? 'execute';
+        const crewx = await this.crewxPool.getForCurrentRequest();
+        const sdkOptions = {
+            threadId,
+            taskId: newTaskId,
+            platform: 'cli',
+            metadata: { thread: threadId, parentTaskId: null, retriedFromTaskId: taskId },
+            cwd: (0, workspace_context_store_js_1.getWorkspacePath)(),
+        };
+        const sdkCall = mode === 'execute'
+            ? crewx.execute(agentRef, retryPrompt, sdkOptions)
+            : crewx.query(agentRef, retryPrompt, sdkOptions);
+        sdkCall.catch((err) => {
+            this.logger.error(`Retry task failed [thread=${threadId}, originalTask=${taskId}, newTask=${newTaskId}]: ${err.message}`, err.stack);
+        });
+        return { taskId: newTaskId, status: 'pending', agentId: task.agent_id };
+    }
     // --- Private helpers ---
     // Reconstruct messages from tasks (used by buildContext and MessageService)
     getThreadMessages(threadId, workspaceId) {
@@ -281,7 +323,7 @@ let ThreadService = class ThreadService {
                             totalCostUsd,
                             sessionId,
                             error: task.error || null,
-                            logs: this.parseLogs(task.logs, 50),
+                            logs: this.parseLogs(task.logs, 50, this.extractAdapterKey(task)),
                         },
                     },
                 });
@@ -350,7 +392,7 @@ let ThreadService = class ThreadService {
         return text.slice(0, maxLen) + '...';
     }
     /** @see TaskService.parseLogs — 동일 역할, ACP 파싱 로직 동기화 필요 */
-    parseLogs(logsJson, logLimit) {
+    parseLogs(logsJson, logLimit, providerId) {
         if (!logsJson)
             return [];
         let rawLogs;
@@ -366,7 +408,7 @@ let ThreadService = class ThreadService {
         for (const log of rawLogs) {
             if (log.level === 'stdout') {
                 try {
-                    const parsed = (0, sdk_1.parseStdoutEvent)(log.timestamp, log.message);
+                    const parsed = (0, sdk_1.parseStdoutEvent)(log.timestamp, log.message, providerId);
                     if (parsed.length > 0) {
                         entries.push(...parsed);
                         continue;
@@ -387,13 +429,13 @@ let ThreadService = class ThreadService {
         }
         return deduped;
     }
-    /** Merge consecutive type=text entries into one (fixes Gemini delta streaming fragmentation) */
+    /** Merge consecutive type=text entries into one while preserving message boundaries. */
     mergeConsecutiveText(entries) {
         const merged = [];
         for (const entry of entries) {
             const prev = merged[merged.length - 1];
             if (prev && prev.type === 'text' && entry.type === 'text') {
-                prev.content = (prev.content || '') + (entry.content || '');
+                prev.content = this.joinTextEntries(prev.content || '', entry.content || '');
             }
             else {
                 merged.push({ ...entry });
@@ -401,6 +443,32 @@ let ThreadService = class ThreadService {
         }
         return merged;
     }
+    joinTextEntries(previous, next) {
+        if (!previous)
+            return next;
+        if (!next)
+            return previous;
+        return previous + next;
+    }
+    extractAdapterKey(row) {
+        if (row.metadata) {
+            try {
+                const meta = JSON.parse(row.metadata);
+                const provider = meta.provider;
+                if (provider) {
+                    const slash = provider.lastIndexOf('/');
+                    return slash >= 0 ? provider.slice(slash + 1) : provider;
+                }
+            }
+            catch {
+                // Ignore malformed task metadata.
+            }
+        }
+        if (row.coding_agent_command) {
+            return row.coding_agent_command.split(/\s/)[0] || undefined;
+        }
+        return undefined;
+    }
     /**
      * ACP providers (claude, opencode) emit the same toolUseId twice — first with
      * a placeholder input, then with the real one. Keep only the last occurrence.
@@ -422,7 +490,8 @@ let ThreadService = class ThreadService {
     }
 };
 exports.ThreadService = ThreadService;
-exports.ThreadService = ThreadService = __decorate([
+exports.ThreadService = ThreadService = ThreadService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [thread_repository_js_1.ThreadRepository])
+    __metadata("design:paramtypes", [thread_repository_js_1.ThreadRepository,
+        crewx_pool_service_js_1.CrewxPoolService])
 ], ThreadService);