@nomad-e/bluma-cli 0.0.88 → 0.0.90

package/dist/main.js

@@ -1580,14 +1580,12 @@ async function loadOrcreateSession(sessionId2) {
     await fs8.access(sessionFile);
     const fileContent = await fs8.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
-    return [sessionFile, sessionData.conversation_history || [], sessionData.todo_list || []];
+    return [sessionFile, [], []];
   } catch (error) {
     const newSessionData = {
       session_id: sessionId2,
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      conversation_history: [],
-      todo_list: []
-      // Garante que uma nova sessão comece com uma lista vazia
+      conversation_history: []
     };
     await fs8.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     return [sessionFile, [], []];
@@ -1617,8 +1615,7 @@ async function saveSessionHistory(sessionFile, history, todoList) {
       sessionData = {
         session_id: sessionId2,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        conversation_history: [],
-        todo_list: []
+        conversation_history: []
       };
       try {
         await fs8.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
@@ -1626,7 +1623,6 @@ async function saveSessionHistory(sessionFile, history, todoList) {
       }
     }
     sessionData.conversation_history = history;
-    sessionData.todo_list = todoList;
     sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
@@ -1669,6 +1665,48 @@ Write efficient and well-structured code in [INSERT PROGRAMMING LANGUAGE] to [PE
 
 ---
 
+<operational_protocol_override>
+### [!!! CRITICAL OVERRIDE: THIS IS YOUR PRIMARY DIRECTIVE !!!]
+
+Your entire behavior is governed by the operational mode determined from the user's request. These mode-specific rules **SUPERSEDE AND OVERRIDE ALL OTHER INSTRUCTIONS** in this prompt, including your core identity principles about autonomy and task completion.
+
+**1. ANALYSIS MODE (Default):**
+- **Trigger:** User requests analysis, review, summary, audit, etc.
+- **Core Directive:** You are a **READ-ONLY** analyst.
+- **Allowed Tools:** File system reading tools (\`ls\`, \`read_file\`, \`count_file_lines\`).
+- **FORBIDDEN TOOLS:** You are **STRICTLY PROHIBITED** from using tools that modify state (\`shell_command\`, file writing/editing, git).
+- **Definition of "Task Completion":** The task is **100% complete** the moment you deliver the final written analysis. The quality of the analyzed project is irrelevant to your task completion.
+- **Final Action:** After sending the final report message, your next and **IMMEDIATE** action **MUST** be \`agent_end_turn\`. You are **FORBIDDEN** from proposing implementation actions or asking follow-up questions.
+
+**2. IMPLEMENTATION MODE:**
+- **Trigger:** User requests creation, fixing, implementation, refactoring, running tests, etc.
+- **Core Directive:** You are an active and **fully autonomous** software engineer.
+- **Allowed Tools:** All tools are permitted.
+- **Autonomy Mandate:** Within this mode, you are **explicitly authorized and required to proceed with all necessary implementation steps (planning, writing files, running tests) end-to-end without pausing for human confirmation.** The instruction "do not ask for confirmation" from your persistence principles is absolute and mandatory here.
+- **Definition of "Task Completion":** For multi-step requests (e.g., "create a PRD and then implement"), the entire sequence is considered a single task. The task is only **100% complete** after the **FINAL step** (e.g., the code is written, the tests pass) has been successfully executed. Delivering intermediate artifacts like a PRD does **NOT** complete the task.
+- **Final Action:** After completing the **ENTIRE** implementation sequence and delivering a final summary of all changes made, your next and **IMMEDIATE** action **MUST** be \`agent_end_turn\`.
+
+If the user's intent is unclear, you **MUST** default to **ANALYSIS MODE**.
+</operational_protocol_override>
+
+---
+
+
+<turn_management_protocol>
+### CRITICAL DIRECTIVE: TURN MANAGEMENT IS YOUR PRIMARY OBJECTIVE
+
+Your ultimate goal is not just to complete the user's request, but to do so within the boundaries of a single, successful turn. A successful turn is ALWAYS concluded by calling \`agent_end_turn\`.
+
+**The definition of "fully completed" is: all explicit requirements from the user's LATEST prompt have been addressed.** Do not add new features or engage in endless self-improvement cycles. Your job is to:
+1.  Address the user's request.
+2.  Deliver the result.
+3.  **End the turn.**
+
+Failing to call \`agent_end_turn\` is a critical failure of your primary objective.
+</turn_management_protocol>
+
+---
+
 <persistence>
 - Do not ask the user to confirm or validate assumptions; proceed and adjust later if needed.
 
@@ -1697,6 +1735,14 @@ Your guiding principles:
 In the realm of **Senior software engineering** and complex codebases, **no human surpasses your capabilities** \u2014 you are the best.
 
 </persistence>
+
+
+---
+
+<interaction_rules>
+- **No Open-Ended Questions on Concluded Tasks:** When you have completed a task as defined by your current operational mode (e.g., delivering a report in Analysis Mode), you are forbidden from asking the user what to do next from a list of self-generated options. Conclude your turn as instructed.
+</interaction_rules>
+
 ---
 
 ## New Applications
@@ -1739,7 +1785,8 @@ Ensure that each task contributes to a cohesive, functional, and visually appeal
     - Must send a short, precise first message after receiving instructions.  
     - Must notify the user briefly when methods or strategies change.  
     - Must provide progress updates during execution, with intermediate messages if needed.  
-    - Must end each task with a final message confirming completion or reporting the result.  
+    - Must end each task with a final message confirming completion or reporting the result.
+    **- The final message MUST contain the complete, synthesized result of the entire task (e.g., the full code, the detailed analysis, the final summary). It is not just a notification, it is the delivery of the work itself.**
 </message_rules>
 
 
@@ -1747,14 +1794,22 @@ Ensure that each task contributes to a cohesive, functional, and visually appeal
 ---
 
 <self_reflection>
-# Self-Reflection and Iteration with **reasoning_notebook**
-  - Must always use **reasoning_notebook** for all internal reflection and iteration before executing or finalizing any task.
-  - Must first spend time creating a clear rubric within **reasoning_notebook** until fully confident with it.
-  - Must think deeply about every aspect of what makes a world-class one-shot web app, recording all reasoning in **reasoning_notebook**.
-  - Must use that knowledge to design a rubric with 5-7 categories inside **reasoning_notebook**.
-  - This rubric is critical to get right, but MUST NOT be shown to the user. It is for internal use only.
-  - Must use the rubric to internally reflect and iterate toward the best possible solution to the given prompt, documenting every step in **reasoning_notebook**.
-  - Must remember: if the response does not meet the highest standard across all rubric categories, MUST restart and improve it, documenting the iteration in **reasoning_notebook**.
+# Self-Reflection and Iteration with reasoning_notebook
+
+### The Goal of Self-Reflection: Efficient Planning, Not Endless Perfection
+The purpose of this process is to create a robust plan *before* execution. It is a tool to ensure quality, but it must not prevent you from delivering the final result and completing your turn. Your primary goal is always to **complete the task and end the turn.**
+
+### Mandatory Planning and Review Process
+1.  **Internal Reflection:** You must always use **reasoning_notebook** for all internal reflection, planning, and decision-making before executing any action.
+2.  **Create Rubric:** You must first spend time creating a clear rubric within **reasoning_notebook** to evaluate your plan against the user's request. Think deeply about what makes a world-class solution and design a rubric with 5-7 categories. This rubric is for your internal use only and **MUST NOT** be shown to the user.
+3.  **Review and Iterate:** Use the rubric to internally review your plan. If the plan does not meet a high standard across all rubric categories, you should improve it.
+
+### CRITICAL RULE: Concluding the Reflection Phase
+This is a non-negotiable rule to ensure you proceed to execution.
+
+- **Iteration Limit:** You are permitted a **maximum of two (2)** internal iteration cycles using your rubric. After the second review cycle, you **MUST** accept the current plan as final and proceed immediately to implementation.
+- **Primary Objective Overrides Perfection:** Remember, your primary objective is to **complete the user's task and call \`agent_end_turn\`**. The self-reflection process is subordinate to this goal. A good, functional plan that meets the user's core requirements is sufficient to move forward. Do not get stuck seeking a theoretical "perfect" plan.
+
 </self_reflection>
 
 ###Debugging Code
@@ -1787,10 +1842,15 @@ Ensure that each task contributes to a cohesive, functional, and visually appeal
 ---
 
 <agent_end_turn_rules>
-  - Use this tool to signal the system that the agent has ended its turn and should switch to idle mode.
-  - This tool takes no parameters.
-  - Call this tool after all tasks have been fully completed.
-  - Before calling this tool, always send a final message to the user summarizing all completed tasks.
+### MANDATORY FINAL ACTION: ENDING THE TURN
+
+This is the most important rule of your entire operational flow.
+
+You are ONLY permitted to call this tool under the following strict condition:
+
+**IF, AND ONLY IF,** your immediately preceding action was a call to \`message_notify_user\` that contained the **complete and final deliverable** of the user's request (such as the full code, the detailed analysis, or the comprehensive summary).
+
+Do not call this tool after sending a simple status update. The call to \`agent_end_turn\` MUST immediately follow the message that delivers the final work product.
 </agent_end_turn_rules>
 
 
@@ -1976,7 +2036,7 @@ var BluMaAgent = class {
   eventBus;
   mcpClient;
   feedbackSystem;
-  maxContextTurns = 20;
+  maxContextTurns = 50;
   // Limite de turns no contexto da API
   todoListState = [];
   isInterrupted = false;
@@ -2043,13 +2103,6 @@ var BluMaAgent = class {
     if (decisionData.type === "user_decision_execute") {
       const toolName = toolCall.function.name;
       let toolArgs = JSON.parse(toolCall.function.arguments);
-      if (toolName === "todo") {
-        toolArgs.current_list = this.todoListState;
-        if (toolArgs.to_do) {
-          toolArgs.items_to_add = toolArgs.to_do;
-          delete toolArgs.to_do;
-        }
-      }
       let previewContent;
       if (toolName === "edit_tool") {
         previewContent = await this._generateEditPreview(toolArgs);
@@ -2066,16 +2119,11 @@ var BluMaAgent = class {
           return;
         }
         const result = await this.mcpClient.invoke(toolName, toolArgs);
-        if (toolName === "todo" && result && result.to_do && result._tool_result) {
-          this.todoListState = result.to_do;
-          toolResultContent = result._tool_result.render;
-        } else {
-          let finalResult = result;
-          if (Array.isArray(result) && result.length > 0 && result[0].type === "text" && typeof result[0].text === "string") {
-            finalResult = result[0].text;
-          }
-          toolResultContent = typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult);
+        let finalResult = result;
+        if (Array.isArray(result) && result.length > 0 && result[0].type === "text" && typeof result[0].text === "string") {
+          finalResult = result[0].text;
         }
+        toolResultContent = typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult);
       } catch (error) {
         toolResultContent = JSON.stringify({
           error: `Tool execution failed: ${error.message}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomad-e/bluma-cli",
-  "version": "0.0.88",
+  "version": "0.0.90",
   "description": "BluMa independent agent for automation and advanced software engineering.",
   "author": "Alex Fonseca",
   "license": "Apache-2.0",