@codebolt/agent 6.1.20 → 6.1.21

package/dist/processor-pieces/messageModifiers/argumentProcessorModifier.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArgumentProcessorModifier = void 0;
 const base_1 = require("../base");
+const promptContext_1 = require("../../unified/base/promptContext");
 class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -19,8 +20,7 @@ class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
             if (!(invocation === null || invocation === void 0 ? void 0 : invocation.args)) {
                 return Promise.resolve(createdMessage);
             }
-            // Find the user message to append arguments to
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            const userMessage = (0, promptContext_1.getCurrentUserMessage)(createdMessage);
             if (!userMessage || typeof userMessage.content !== 'string') {
                 return Promise.resolve(createdMessage);
             }
@@ -37,23 +37,19 @@ class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
                 }
                 appendContent = `\n\nArguments: ${argsToAppend}`;
             }
-            // Update the user message with appended arguments
-            const updatedMessages = createdMessage.message.messages.map(msg => {
-                if (msg.role === 'user' && typeof msg.content === 'string' && msg === userMessage) {
-                    return {
-                        ...msg,
-                        content: msg.content + appendContent
-                    };
-                }
-                return msg;
-            });
+            const updatedMessage = (0, promptContext_1.updateCurrentUserMessage)(createdMessage, (message) => ({
+                ...message,
+                content: typeof message.content === 'string'
+                    ? message.content + appendContent
+                    : message.content,
+            }));
             return Promise.resolve({
+                ...updatedMessage,
                 message: {
-                    ...createdMessage.message,
-                    messages: updatedMessages
+                    ...updatedMessage.message,
                 },
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     argumentsProcessed: true,
                     argumentsAppended: appendContent.trim()
                 }

package/dist/processor-pieces/messageModifiers/atFileProcessorModifier.d.ts

@@ -19,7 +19,6 @@ export declare class AtFileProcessorModifier extends BaseMessageModifier {
     private readManyFiles;
     private readFileContent;
     private getFolderStructure;
-    private findLastUserMessage;
     private getProjectPath;
     private isReadableTextFile;
     private isLikelyBinaryFile;

package/dist/processor-pieces/messageModifiers/atFileProcessorModifier.js

@@ -41,6 +41,7 @@ const base_1 = require("../base");
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("../../unified/base/promptContext");
 class AtFileProcessorModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -74,39 +75,30 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
             if (!result.success) {
                 return createdMessage;
             }
-            // Update the user message with processed content
-            const messages = [...createdMessage.message.messages];
-            const lastUserMessageIndex = this.findLastUserMessage(messages);
-            if (lastUserMessageIndex !== -1 && result.processedContent) {
-                const lastUserMessage = messages[lastUserMessageIndex];
-                if (lastUserMessage) {
-                    // Convert string content to array format if needed
-                    let currentContent;
-                    if (Array.isArray(lastUserMessage.content)) {
-                        currentContent = lastUserMessage.content;
-                    }
-                    else {
-                        // Convert string content to array format
-                        currentContent = [{ type: 'text', text: lastUserMessage.content }];
-                    }
-                    // Ensure processedContent is in array format
+            const currentUserMessage = (0, promptContext_1.getCurrentUserMessage)(createdMessage);
+            const updatedMessage = currentUserMessage && result.processedContent
+                ? (0, promptContext_1.updateCurrentUserMessage)(createdMessage, (message) => {
+                    const currentContent = Array.isArray(message.content)
+                        ? message.content
+                        : [{ type: 'text', text: message.content }];
                     const newContent = Array.isArray(result.processedContent)
                         ? result.processedContent
                         : [{ type: 'text', text: result.processedContent }];
-                    // Merge existing content with processed content
-                    messages[lastUserMessageIndex] = {
-                        role: lastUserMessage.role,
+                    return {
+                        ...message,
+                        type: 'message',
+                        role: 'user',
                         content: [...currentContent, ...newContent]
                     };
-                }
-            }
+                })
+                : createdMessage;
             return {
+                ...updatedMessage,
                 message: {
-                    ...createdMessage.message,
-                    messages
+                    ...updatedMessage.message,
                 },
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     atFileProcessed: true,
                     processedFiles: mentionedFiles,
                     processedFolders: mentionedFolders,
@@ -348,15 +340,6 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
         }
         return lines.join('\n');
     }
-    findLastUserMessage(messages) {
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const message = messages[i];
-            if (message && message.role === 'user') {
-                return i;
-            }
-        }
-        return -1;
-    }
     async getProjectPath() {
         const effectiveProjectPath = process.env['CODEBOLT_EFFECTIVE_PROJECT_PATH'] || process.env['CODEBOLT_PROJECT_PATH'];
         if (effectiveProjectPath) {

package/dist/processor-pieces/messageModifiers/capabilityContextModifier.js

@@ -36,10 +36,11 @@ class CapabilityContextModifier extends base_1.BaseMessageModifier {
             role: 'user',
             content: this.formatSelectedCapabilitiesContext(selectedCapabilities, selectedCapabilityInfo, skillContexts),
         };
+        const updatedMessage = (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage);
         return {
-            ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
+            ...updatedMessage,
             metadata: {
-                ...createdMessage.metadata,
+                ...updatedMessage.metadata,
                 selectedCapabilities,
                 selectedCapabilitiesProcessed: true,
                 selectedCapabilityNames: skillContexts.map((context) => context.name),

package/dist/processor-pieces/messageModifiers/chatHistoryMessageModifier.d.ts

@@ -15,4 +15,11 @@ export declare class ChatHistoryMessageModifier extends BaseMessageModifier {
     modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private getChatHistory;
     setMaxHistoryMessages(max: number): void;
+    private addMissingToolResponses;
+    private getStandaloneToolCall;
+    private getFunctionCallOutputId;
+    private getAssistantToolCallId;
+    private getAssistantToolCallName;
+    private getAssistantToolCallArguments;
+    private buildMissingToolResponseContent;
 }

package/dist/processor-pieces/messageModifiers/chatHistoryMessageModifier.js

@@ -25,11 +25,12 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
             if (!chatHistory || chatHistory.length === 0) {
                 return createdMessage;
             }
+            const updatedMessage = (0, promptContext_1.prependTranscriptMessages)(createdMessage, chatHistory);
             // Directly use the chat history messages - they're already in MessageObject format
             return {
-                ...(0, promptContext_1.prependTranscriptMessages)(createdMessage, chatHistory),
+                ...updatedMessage,
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     chatHistoryAdded: true,
                     chatHistoryCount: chatHistory.length,
                     threadId: originalRequest.threadId
@@ -47,40 +48,20 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
         try {
             const response = await codeboltjs_1.default.chat.getChatHistory(threadId);
             // Check if response has messages array
-            if (!(response === null || response === void 0 ? void 0 : response.chats) || !((_a = response === null || response === void 0 ? void 0 : response.chats) === null || _a === void 0 ? void 0 : _a.messages) || !Array.isArray((_b = response === null || response === void 0 ? void 0 : response.chats) === null || _b === void 0 ? void 0 : _b.messages) || ((_c = response === null || response === void 0 ? void 0 : response.chats) === null || _c === void 0 ? void 0 : _c.messages.length) === 0) {
+            if (!(response === null || response === void 0 ? void 0 : response.chats) || !((_a = response === null || response === void 0 ? void 0 : response.chats) === null || _a === void 0 ? void 0 : _a.input) || !Array.isArray((_b = response === null || response === void 0 ? void 0 : response.chats) === null || _b === void 0 ? void 0 : _b.input) || ((_c = response === null || response === void 0 ? void 0 : response.chats) === null || _c === void 0 ? void 0 : _c.input.length) === 0) {
                 return [];
             }
-            let historyMessages = (_d = response === null || response === void 0 ? void 0 : response.chats) === null || _d === void 0 ? void 0 : _d.messages;
+            let historyMessages = (_d = response === null || response === void 0 ? void 0 : response.chats) === null || _d === void 0 ? void 0 : _d.input;
             // Thread filtering is now handled by the API directly via threadId parameter
             // Filter out system messages if not included
             if (!this.includeSystemMessages) {
                 historyMessages = historyMessages.filter((msg) => msg.role !== 'system');
             }
-            // Limit the number of messages
-            // will do it later
-            if (false) {
+            historyMessages = historyMessages.filter((message) => !(0, promptContext_1.isGeneratedUserContextMessage)(message));
+            if (this.maxHistoryMessages > 0 && historyMessages.length > this.maxHistoryMessages) {
                 historyMessages = historyMessages.slice(-this.maxHistoryMessages);
             }
-            // Check if the last message is an assistant message with tool_calls
-            // If so, add tool response messages for each tool_call
-            const lastMessage = historyMessages[historyMessages.length - 1];
-            if (lastMessage &&
-                lastMessage.role === 'assistant' &&
-                lastMessage.tool_calls &&
-                Array.isArray(lastMessage.tool_calls) &&
-                lastMessage.tool_calls.length > 0) {
-                // Add tool response messages for each tool_call
-                const toolResponseMessages = [];
-                for (const toolCall of lastMessage.tool_calls) {
-                    toolResponseMessages.push({
-                        role: 'tool',
-                        content: `Tool call "${toolCall.function.name}" was not executed. This appears to be from a previous incomplete conversation. The tool was called with arguments: ${toolCall.function.arguments}`,
-                        tool_call_id: toolCall.id
-                    });
-                }
-                // Return original messages + tool responses + context message
-                return [...historyMessages, ...toolResponseMessages];
-            }
+            historyMessages = this.addMissingToolResponses(historyMessages);
             // Add a system message to indicate this is previous conversation
             const contextMessage = {
                 role: 'user',
@@ -98,5 +79,132 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
     setMaxHistoryMessages(max) {
         this.maxHistoryMessages = max;
     }
+    addMissingToolResponses(historyMessages) {
+        const existingToolResponseIds = new Set();
+        for (const message of historyMessages) {
+            const functionCallOutputId = this.getFunctionCallOutputId(message);
+            if (functionCallOutputId) {
+                existingToolResponseIds.add(functionCallOutputId);
+            }
+            if (typeof message.tool_call_id === 'string') {
+                existingToolResponseIds.add(message.tool_call_id);
+            }
+        }
+        const repairedMessages = [];
+        for (const message of historyMessages) {
+            repairedMessages.push(message);
+            const standaloneToolCall = this.getStandaloneToolCall(message);
+            if (standaloneToolCall && !existingToolResponseIds.has(standaloneToolCall.id)) {
+                repairedMessages.push({
+                    type: 'function_call_output',
+                    call_id: standaloneToolCall.id,
+                    output: this.buildMissingToolResponseContent(standaloneToolCall.name, standaloneToolCall.arguments),
+                    status: 'completed',
+                });
+                existingToolResponseIds.add(standaloneToolCall.id);
+            }
+            const assistantToolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+            for (const toolCall of assistantToolCalls) {
+                const toolCallId = this.getAssistantToolCallId(toolCall);
+                if (!toolCallId || existingToolResponseIds.has(toolCallId)) {
+                    continue;
+                }
+                const toolName = this.getAssistantToolCallName(toolCall);
+                const toolArguments = this.getAssistantToolCallArguments(toolCall);
+                repairedMessages.push({
+                    role: 'tool',
+                    content: this.buildMissingToolResponseContent(toolName, toolArguments),
+                    tool_call_id: toolCallId,
+                });
+                existingToolResponseIds.add(toolCallId);
+            }
+        }
+        return repairedMessages;
+    }
+    getStandaloneToolCall(message) {
+        var _a, _b;
+        const typedMessage = message;
+        if (typedMessage.type !== 'function_call') {
+            return null;
+        }
+        const id = typeof typedMessage.call_id === 'string'
+            ? typedMessage.call_id
+            : typeof typedMessage.id === 'string'
+                ? typedMessage.id
+                : '';
+        if (!id) {
+            return null;
+        }
+        const name = typeof typedMessage.name === 'string'
+            ? typedMessage.name
+            : typeof ((_a = typedMessage.function) === null || _a === void 0 ? void 0 : _a.name) === 'string'
+                ? typedMessage.function.name
+                : 'unknown';
+        const toolArguments = typeof typedMessage.arguments === 'string'
+            ? typedMessage.arguments
+            : typeof ((_b = typedMessage.function) === null || _b === void 0 ? void 0 : _b.arguments) === 'string'
+                ? typedMessage.function.arguments
+                : '';
+        return {
+            id,
+            name,
+            arguments: toolArguments,
+        };
+    }
+    getFunctionCallOutputId(message) {
+        const typedMessage = message;
+        if (typedMessage.type === 'function_call_output' &&
+            typeof typedMessage.call_id === 'string') {
+            return typedMessage.call_id;
+        }
+        return null;
+    }
+    getAssistantToolCallId(toolCall) {
+        if (!toolCall || typeof toolCall !== 'object') {
+            return null;
+        }
+        const typedToolCall = toolCall;
+        if (typeof typedToolCall.id === 'string') {
+            return typedToolCall.id;
+        }
+        if (typeof typedToolCall.call_id === 'string') {
+            return typedToolCall.call_id;
+        }
+        return null;
+    }
+    getAssistantToolCallName(toolCall) {
+        var _a;
+        if (!toolCall || typeof toolCall !== 'object') {
+            return 'unknown';
+        }
+        const typedToolCall = toolCall;
+        if (typeof typedToolCall.name === 'string') {
+            return typedToolCall.name;
+        }
+        if (typeof ((_a = typedToolCall.function) === null || _a === void 0 ? void 0 : _a.name) === 'string') {
+            return typedToolCall.function.name;
+        }
+        return 'unknown';
+    }
+    getAssistantToolCallArguments(toolCall) {
+        var _a;
+        if (!toolCall || typeof toolCall !== 'object') {
+            return '';
+        }
+        const typedToolCall = toolCall;
+        if (typeof typedToolCall.arguments === 'string') {
+            return typedToolCall.arguments;
+        }
+        if (typeof ((_a = typedToolCall.function) === null || _a === void 0 ? void 0 : _a.arguments) === 'string') {
+            return typedToolCall.function.arguments;
+        }
+        return '';
+    }
+    buildMissingToolResponseContent(toolName, toolArguments) {
+        if (toolName.includes('attempt_completion')) {
+            return 'The user is satisfied with the result.';
+        }
+        return `Tool call "${toolName}" was not executed. This appears to be from a previous incomplete conversation. The tool was called with arguments: ${toolArguments}`;
+    }
 }
 exports.ChatHistoryMessageModifier = ChatHistoryMessageModifier;

package/dist/processor-pieces/messageModifiers/chatRecordingModifier.js

@@ -107,12 +107,12 @@ class ChatRecordingModifier extends base_1.BaseMessageModifier {
             }
             const timestamp = new Date().toISOString();
             // Record each message
-            for (const message of createdMessage.message.messages) {
+            for (const message of createdMessage.message.input) {
                 const record = {
                     timestamp,
                     messageId: (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a['messageId'],
                     threadId: (_b = createdMessage.metadata) === null || _b === void 0 ? void 0 : _b['threadId'],
-                    role: message.role,
+                    role: message.role || 'assistant',
                     content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
                 };
                 if (this.options.includeMetadata) {
@@ -129,7 +129,7 @@ class ChatRecordingModifier extends base_1.BaseMessageModifier {
             }
         }
         catch (error) {
-            console.error('Error recording chat messages:', error);
+            console.error('Error recording chat input:', error);
         }
     }
     async writeRecord(record) {

package/dist/processor-pieces/messageModifiers/contextAssemblyModifier.js

@@ -45,6 +45,7 @@ class ContextAssemblyModifier extends base_1.BaseMessageModifier {
                 return createdMessage;
             }
             const contextMessage = {
+                type: 'message',
                 role: this.options.messageRole,
                 content: contextContent,
             };
@@ -54,7 +55,7 @@ class ContextAssemblyModifier extends base_1.BaseMessageModifier {
             return {
                 ...updatedMessage,
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     contextAssemblyAdded: true,
                     contextAssemblyStats: {
                         totalTokens: context.total_tokens,
@@ -76,7 +77,7 @@ class ContextAssemblyModifier extends base_1.BaseMessageModifier {
             scope_variables: { ...this.options.scopeVariables },
         };
         if (this.options.includeUserInput) {
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            const userMessage = (0, promptContext_1.getCurrentUserMessage)(createdMessage);
             if (userMessage && typeof userMessage.content === 'string') {
                 request.input = userMessage.content;
             }
@@ -137,7 +138,7 @@ class RuleBasedContextModifier extends base_1.BaseMessageModifier {
         var _a;
         try {
             // First evaluate rules to determine which memories to include
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            const userMessage = (0, promptContext_1.getCurrentUserMessage)(createdMessage);
             const input = userMessage && typeof userMessage.content === 'string' ? userMessage.content : undefined;
             const request = {
                 scope_variables: { ...this.options.scopeVariables },
@@ -181,14 +182,16 @@ class RuleBasedContextModifier extends base_1.BaseMessageModifier {
                 role: this.options.messageRole,
                 content: contextContent,
             };
-            const messages = [...createdMessage.message.messages, contextMessage];
+            const updatedMessage = this.options.messageRole === 'user'
+                ? (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage)
+                : (0, promptContext_1.appendSystemContextMessage)(createdMessage, contextMessage);
             return {
+                ...updatedMessage,
                 message: {
-                    ...createdMessage.message,
-                    messages,
+                    ...updatedMessage.message,
                 },
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     ruleBasedContextAdded: true,
                     ruleEvaluation: {
                         matchedRules: ruleResult.data.matched_rules,
@@ -241,7 +244,7 @@ class MemoryTypeContextModifier extends base_1.BaseMessageModifier {
                     additionalVariables = this.resolveVariables(requiredVarsResponse.data, createdMessage);
                 }
             }
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            const userMessage = (0, promptContext_1.getCurrentUserMessage)(createdMessage);
             const input = userMessage && typeof userMessage.content === 'string' ? userMessage.content : undefined;
             const request = {
                 scope_variables: { ...this.options.scopeVariables },
@@ -268,17 +271,20 @@ class MemoryTypeContextModifier extends base_1.BaseMessageModifier {
                 return createdMessage;
             }
             const contextMessage = {
+                type: 'message',
                 role: this.options.messageRole,
                 content: contextContent,
             };
-            const messages = [...createdMessage.message.messages, contextMessage];
+            const updatedMessage = this.options.messageRole === 'user'
+                ? (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage)
+                : (0, promptContext_1.appendSystemContextMessage)(createdMessage, contextMessage);
             return {
+                ...updatedMessage,
                 message: {
-                    ...createdMessage.message,
-                    messages,
+                    ...updatedMessage.message,
                 },
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     memoryTypeContextAdded: true,
                     memoryNames: this.options.memoryNames,
                     contextAssemblyStats: {

package/dist/processor-pieces/messageModifiers/directoryContextModifier.d.ts

@@ -24,6 +24,7 @@ export declare class DirectoryContextModifier extends BaseMessageModifier {
      * @returns A promise resolving to the formatted folder structure string.
      */
     private getFolderStructure;
+    private isTruncated;
     private readFullStructure;
     /**
      * Reads the directory structure using BFS, respecting maxItems.

package/dist/processor-pieces/messageModifiers/directoryContextModifier.js

@@ -106,10 +106,11 @@ ${folderStructure}`;
                 role: 'user', // Note: gemini-cli adds this as user message, not system
                 content: directoryContext
             };
+            const updatedMessage = (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage);
             return Promise.resolve({
-                ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
+                ...updatedMessage,
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     directoryContextAdded: true,
                     workspaceDirectories
                 }
@@ -226,20 +227,8 @@ ${folderStructure}`;
             const structureLines = [];
             // Pass true for isRoot for the initial call
             this.formatStructure(structureRoot, '', true, true, structureLines);
-            // 3. Build the final output string
-            function isTruncated(node) {
-                if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
-                    return true;
-                }
-                for (const sub of node.subFolders) {
-                    if (isTruncated(sub)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
             let summary = `Showing up to ${mergedOptions.maxItems} items (files + folders).`;
-            if (isTruncated(structureRoot)) {
+            if (this.isTruncated(structureRoot)) {
                 summary += ` Folders or files indicated with ${TRUNCATION_INDICATOR} contain more items not shown, were ignored, or the display limit (${mergedOptions.maxItems} items) was reached.`;
             }
             return `${summary}\n\n${resolvedPath}${path.sep}\n${structureLines.join('\n')}`;
@@ -249,6 +238,17 @@ ${folderStructure}`;
             return `Error processing directory "${resolvedPath}": ${getErrorMessage(error)}`;
         }
     }
+    isTruncated(node) {
+        if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
+            return true;
+        }
+        for (const subFolder of node.subFolders) {
+            if (this.isTruncated(subFolder)) {
+                return true;
+            }
+        }
+        return false;
+    }
     async readFullStructure(rootPath, options) {
         const rootName = path.basename(rootPath);
         const rootNode = {

package/dist/processor-pieces/messageModifiers/environmentContextModifier.d.ts

@@ -14,6 +14,7 @@ export declare class EnvironmentContextModifier extends BaseMessageModifier {
     constructor(options?: EnvironmentContextOptions);
     modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private formatMentionedEnvironments;
+    private formatPendingAsyncTasks;
     private readProjectAgentMd;
     private readAgentInstructionFile;
     private generateFullContext;

package/dist/processor-pieces/messageModifiers/environmentContextModifier.js

@@ -102,6 +102,7 @@ Effective project directory for this task: ${currentDir}
 ${baseProjectPath ? `CodeBolt base project directory: ${baseProjectPath}
 CodeBolt app-level configuration, providers, plugins, and .codebolt data are loaded from the base project directory. Code changes for the task should still target the effective project directory unless the user explicitly says otherwise.` : ''}
 ${directoryListing}
+Async task policy: long-running commands and child threads are tracked as async tasks with execution_mode foreground_scoped, auto_scoped, background_scoped, or background_detached. Scoped tasks are owned by the current agent run and are stopped if the user force-stops the agent. Before completing, use async_task_list to inspect unresolved scoped work and async_task_control to wait, stop, or explicitly detach each running task. background_detached tasks survive user force-stop and natural completion, so detach only intentional background services such as dev servers.
             `.trim();
             // Prepare context parts (same as gemini-cli)
             const contextParts = [environmentContext];
@@ -119,6 +120,10 @@ ${directoryListing}
             if (mentionedEnvironmentContext) {
                 contextParts.push(mentionedEnvironmentContext);
             }
+            const asyncTaskContext = await this.formatPendingAsyncTasks();
+            if (asyncTaskContext) {
+                contextParts.push(asyncTaskContext);
+            }
             // Add full file context if enabled (just like gemini-cli does)
             if (this.options.enableFullContext) {
                 try {
@@ -137,10 +142,11 @@ ${directoryListing}
                 role: 'user',
                 content: finalContent
             };
+            const updatedMessage = (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage);
             return Promise.resolve({
-                ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
+                ...updatedMessage,
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     environmentContextAdded: true,
                     projectAgentMdContextAdded: Boolean(agentMdContext),
                     fullContextAdded: this.options.enableFullContext,
@@ -187,6 +193,7 @@ ${directoryListing}
             'The user explicitly mentioned these environments with #. Treat them as routing context, not as an automatic active-environment selection.',
             'If the user asks to run, start, delegate, create, or continue work in one of these environments, first inspect this mentioned environment list and choose the matching environment.',
             'Use the thread tool `thread_create_background` to create a background thread in the selected remote environment. Pass the selected environment object in `environment`, set `isRemoteTask: true`, and put the requested work in `userMessage` or `task`.',
+            'If the next step depends on that child thread finishing, use `async_task_control` with taskId `thread:<threadId>` and action `wait` before continuing.',
             'If `thread_create_background` is not available in the current tool list, first use the tool search capability, such as `tool_search`, to find the thread/background-thread creation tool and then use the matching tool.',
             'If multiple mentioned environments could match and the user did not specify which one, ask a brief clarification before creating the background thread.',
             'Do not call environment management tools or change the active environment just because an environment was mentioned.',
@@ -194,6 +201,45 @@ ${directoryListing}
             '</mentioned-environments>',
         ].join('\n');
     }
+    async formatPendingAsyncTasks() {
+        try {
+            const response = await codeboltjs_1.default.asyncTask.listTasks({
+                scope: 'thread',
+            });
+            const tasks = Array.isArray(response === null || response === void 0 ? void 0 : response.tasks) ? response.tasks : [];
+            const unresolvedTasks = tasks.filter((task) => task &&
+                task.executionMode !== 'background_detached' &&
+                !['completed', 'failed', 'stopped'].includes(task.status));
+            const detachedTasks = tasks.filter((task) => task &&
+                task.executionMode === 'background_detached' &&
+                !['completed', 'failed', 'stopped'].includes(task.status));
+            if (unresolvedTasks.length === 0 && detachedTasks.length === 0) {
+                return null;
+            }
+            const sections = [];
+            if (unresolvedTasks.length > 0) {
+                sections.push([
+                    '<pending_async_tasks>',
+                    'These scoped async tasks are still unresolved for this thread. Before completing, choose wait, stop, or detach for each task using async_task_control. Detach only intentional background services that should survive agent stop.',
+                    JSON.stringify(unresolvedTasks, null, 2),
+                    '</pending_async_tasks>',
+                ].join('\n'));
+            }
+            if (detachedTasks.length > 0) {
+                sections.push([
+                    '<detached_async_tasks>',
+                    'These background_detached async tasks are still running in the background for this thread. They do not block completion and survive user force-stop. Stop them with async_task_control if they are no longer needed.',
+                    JSON.stringify(detachedTasks, null, 2),
+                    '</detached_async_tasks>',
+                ].join('\n'));
+            }
+            return sections.join('\n\n');
+        }
+        catch (error) {
+            console.error('Error reading pending async tasks:', error);
+            return null;
+        }
+    }
     async readProjectAgentMd(basePath, title = 'Project Agent Instructions') {
         const instructionFiles = [
             path.join(basePath, '.codebolt', 'agent.md'),

package/dist/processor-pieces/messageModifiers/ideContextModifier.js

@@ -34,10 +34,11 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
                 this.lastSentIdeContext = newIdeContext;
             }
             this.forceFullContext = false;
+            const updatedMessage = (0, promptContext_1.appendSystemContextMessage)(createdMessage, ideContextMessage);
             return Promise.resolve({
-                ...(0, promptContext_1.appendSystemContextMessage)(createdMessage, ideContextMessage),
+                ...updatedMessage,
                 metadata: {
-                    ...createdMessage.metadata,
+                    ...updatedMessage.metadata,
                     ideContextAdded: true,
                     ideContextType: this.forceFullContext ? 'full' : 'incremental'
                 }