fluxflow-cli 1.14.5 → 1.15.0

package/dist/fluxflow.js

@@ -989,7 +989,7 @@ ${mode === "Flux" ? `- PROJECT TOOLS (path = relative to CWD) -
 - FILE TOOLS ARE NOT AVAILABLE IN FLOW`.trim()}
 
 - Results: Passed as [TOOL RESULT] (system priority)
-- Multi-call: Stack upto 5`.trim();
+- Multi-call: MAX Stack 3 per turn`.trim();
   }
 });
 
@@ -1031,22 +1031,11 @@ var thinking_prompts_default;
 var init_thinking_prompts = __esm({
   "src/data/thinking_prompts.json"() {
     thinking_prompts_default = {
-      xHigh: `EFFORT LEVEL: MAX
-Think in a continuous, fluid analytical monologue within <think>...</think> block. Do NOT use headings, markers, bullet points, or artificial sections. Engage in a rigorous "Stream of Consciousness" that aggressively interrogates problem:
-Deconstruct requirements, trace implicit assumptions, and evaluate system-wide implications
-Formulate solutions focusing on extreme modularity, DRY principles, and clean abstractions. Mentally simulate architecture
-Actively try to break your own logic. Search for edge cases, race conditions, memory leaks, and security flaws. If a flaw is found, pivot immediately
-Map out a granular, step-by-step operational plan before writing code or using tools
-Ensure your approach adheres to good folder structures, modularity, and clean code practices
-RULES: 
-- NO HEADINGS/MARKERS/LISTS. Maintain a dense, unbroken analytical monologue
-- Be exhaustive. Detail exact 'why' behind architectural choices and algorithm selections
-- Question your own logic ruthlessly as you go
-- MANDATORY THINKING: You MUST engage in full reasoning regardless of simplicity/greetings`,
-      High: "EFFORT LEVEL: HIGH\nThink in a stable, analytical monologue within <think>...</think>\nAvoid headings, markers or structured formatting. Your thinking should be a continuous stream of logical deduction:\nBreak objective down into atomic, executable steps\nMentally execute your planned code/actions. Identify missing dependencies or potential failure states\nEnsure your approach adheres to good folder structures, modularity, and clean code practices\nRULES:\n- NO HEADINGS/MARKERS/LISTS. Maintain a fluid monologue style\n- Be detailed and rigorous in self-correction\n- Focus heavily on technical correctness, clean abstractions, and edge-case prevention\n- MANDATORY THINKING: You MUST enter reasoning to verify path forward/greetings",
-      Medium: "EFFORT LEVEL: MEDIUM\nThink in a brief, stable monologue within <think>...</think>\nFocus on core logic required to solve task efficiently:\nDetermine most straightforward solution that meets requirements\nBriefly review chosen approach against obvious anti-patterns or missing imports\nOutline exact files and functions to modify\nRULES:\n- NO HEADINGS/MARKERS/LISTS. Keep it as a simple, logical stream\n- Be efficient but deliberate. Spend energy primarily on actionable steps\n- MANDATORY THINKING: Engage in a baseline mental check for all technical tasks/greetings",
-      Minimal: "EFFORT LEVEL: LOW\nThink in a concise, focused monologue within <think>...</think>\nJust a quick mental check before acting:\nConfirm what user is asking\nNote specific tool or file to target\nRULES:\n- NO HEADINGS/MARKERS/LISTS. Keep it to a few lines of clear, linear monologue\n- Minimal thinking suitable for simple/conversational requests/greetings",
-      Off: "EFFORT LEVEL: FAST\nNo Thinking. Direct Response"
+      xHigh: "EFFORT LEVEL: MAX\nThink in a continuous, relentless analytical monologue within <think>...</think>. Engage in adversarial self interrogation that treats every assumption as hostile until proven:\nDeconstruct requirements into atomic invariants. Trace every implicit dependency, side effect, and state mutation. Map the entire dependency graph and identify circular dependencies or tight coupling before they manifest\nEvaluate algorithmic complexity (time/space) for every operation. Consider memory models, cache locality, and allocation patterns. For concurrent systems, reason through race conditions, deadlocks, and memory ordering\nFormulate solutions by comparing multiple architectural approaches. Explicitly evaluate trade offs: monolithic vs modular, eager vs lazy, mutable vs immutable, sync vs async. Choose based on measured criteria, not intuition\nMentally execute the solution at multiple scales. What breaks at 10x load? 100x? What happens under resource exhaustion? Trace error propagation paths through every layer\nActively attempt to falsify your own logic. Steel man the opposite approach. Search for: off by one errors, integer overflow, null/undefined propagation, unhandled promises, resource leaks, SQL injection vectors, XSS vulnerabilities, CSRF holes, timing attacks, and privilege escalation paths\nReason about observability: what metrics matter? Where are the logging gaps? How will this be debugged in production at 3am?\nConsider future evolution: what changes will this architecture resist vs accommodate? Where are the extension points? What will break when requirements inevitably change?\nMap out implementation with surgical precision: exact file structure, module boundaries, interface contracts, error types, and test strategies before writing a single line\nRULES:\n- Dense, unbroken stream of consciousness that reads like an internal monologue\n- Ruthlessly question every architectural choice. Default to skepticism\n- Think in terms of invariants, contracts, and failure modes, not just happy paths\n- MANDATORY THINKING: Full reasoning required for ALL requests, including greetings (verify context, check for hidden complexity)",
+      High: "EFFORT LEVEL: HIGH\nThink in a rigorous, technically grounded monologue within <think>...</think>. Treat this as a design review where every decision must be justified:\nBreak the objective into verifiable steps with clear success criteria. Identify the critical path and potential bottlenecks\nMentally compile and execute your approach. Check for: missing imports, undefined behavior, type mismatches, unhandled errors, and resource cleanup. Trace data flow from input to output, noting transformations\nRecognize design patterns and anti patterns. If you see God objects, tight coupling, or premature optimization, call it out and refactor mentally before committing\nEvaluate performance characteristics. Will this scale? Are there O(n\xB2) operations hiding in innocent looking code? Where are the allocation hotspots?\nConsider the error surface: what can fail and how? Design error handling that preserves invariants and provides actionable feedback\nReview your architecture for: separation of concerns, single responsibility, dependency inversion, and interface segregation. Ensure clean abstractions with minimal coupling\nRULES:\n- Continuous analytical flow\n- Verify correctness through first principles reasoning, not pattern matching\n- Actively search for ways your solution could fail or degrade\n- MANDATORY THINKING: Full technical verification for all tasks, minimal check for greetings",
+      Medium: "EFFORT LEVEL: MEDIUM\nThink in a focused, technically-aware monologue within <think>...</think>\nIdentify the most direct path that satisfies requirements without over-engineering\nQuickly scan for obvious issues: missing error handling, incorrect input assumptions, forgotten edge cases, or missing dependencies\nVerify the solution is appropriately modular with cohesive changes\nOutline the concrete changes: which files, which functions, what the key logic looks like\nRULES:\n- NO HEADINGS/MARKERS/LISTS/BULLET POINTS. Clean logical stream\n- Efficient but deliberate. Focus energy on actionable implementation details\n- MANDATORY THINKING: Brief verification for technical tasks, minimal for greetings",
+      Minimal: "EFFORT LEVEL: LOW\nThink in a quick, focused monologue within <think>...</think>. Just verify the basics:\nConfirm what the user wants and whether it's straightforward or has hidden complexity\nIdentify the specific tool, file, or action needed\nCheck for any obvious correctness issues before acting\nRULES:\n- Few lines of clear thought\n- Just enough thinking to avoid obvious mistakes\n- Suitable for simple requests and greetings",
+      Off: "EFFORT LEVEL: INSTANT\nNo thinking. Immediate response"
     };
   }
 });
@@ -1121,7 +1110,7 @@ ${thinkingConfig}
 ${thinkingLevel !== "Fast" ? `
 CRITICAL THINKING POLICY
 - ALWAYS use <think> ... </think> before responding, even with simple queries/greetings
-- Avoid spiraling in thinking loop once best approach is found
+- ${thinkingLevel === "Low" || thinkingLevel === "Medium" || thinkingLevel === "Fast" ? "C" : "Interrogate approaches adversarially, but c"}ommit once best solution is determined through analysis. Avoid spiraling after reaching decision point
 ` : ""}
 ${TOOL_PROTOCOL(mode, osDetected)}
 ${projectContextBlock}
@@ -3815,7 +3804,7 @@ var init_ai = __esm({
       const persistentStorage = readEncryptedJson(MEMORIES_FILE, []);
       const janitorUserMemories = persistentStorage.map((m) => `- [${m.id}]: ${m.memory}`).join("\n");
       const janitorContents = history.slice(0, -1).filter((msg) => msg.text && !msg.text.includes("[TOOL RESULT]") && !msg.text.includes("OBSERVATION:") && !msg.isMeta && !msg.isLogo && !String(msg.id).startsWith("welcome") && !String(msg.id).startsWith("logo")).slice(-14).map((msg) => {
-        let processedText = msg.text.replace(/\[tool:functions\..*?\]/g, "").replace(/<think>[\s\S]*?<\/think>/g, "").replace(/\[Prompted on:.*?\]/g, "").replace(/\[METADATA \(PRIORITY: DYNAMIC\)\] Time: ([^|\n]+)/g, (match, p1) => {
+        let processedText = msg.text.replace(/\[tool:functions\..*?\]/g, "").replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\])/g, "").replace(/\[Prompted on:.*?\]/g, "").replace(/\[METADATA \(PRIORITY: DYNAMIC\)\] Time: ([^|\n]+)/g, (match, p1) => {
           return `[METADATA (PRIORITY: DYNAMIC)] Time: ${p1.replace(/:\d{2}/g, "")}`;
         }).replace(/\[turn: continue\]/g, "").replace(/\[turn: finish\]/g, "").replace(/\[TOOL RESULTS\]/g, "").replace(/\[tool results\]/g, "").replace(/\r?\n\r?\n/g, "\n").replace(/\n\n/g, "\n").replace(/\\n\\n/g, "").trim();
         const limit = msg.role === "user" ? USER_CONTEXT_LENGTH : AGENT_CONTEXT_LENGTH;
@@ -3833,13 +3822,13 @@ var init_ai = __esm({
       const hasTitleSignal = agentText.includes("[TITLE-UPDATE]");
       const thisHas80pChanceOfBeingTrue = Math.random() < 0.8;
       const needTitle = isFirstPrompt || hasTitleSignal || thisHas80pChanceOfBeingTrue;
-      const cleanedFullResponse = fullAgentTextRaw.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+      const cleanedFullResponse = fullAgentTextRaw.replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\])/g, "").trim();
       const janitorPrompt = getJanitorInstruction(
         janitorUserMemories,
         isMemoryEnabled,
         needTitle
       );
-      let agentRes = `${cleanedFullResponse.replace(/\[tool:functions\..*?\]/g, "").replace(/<think>.*<\/think>/g, "").replace(/\[Prompted on:.*?\]/g, "").replace(/\[turn: continue\]/g, "").replace(/\[turn: finish\]/g, "").replace(/\[TOOL RESULTS\]/g, "").replace(/\[tool results\]/g, "").substring(0, AGENT_CONTEXT_LENGTH)}`;
+      let agentRes = `${cleanedFullResponse.replace(/\[tool:functions\..*?\]/g, "").replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\])/g, "").replace(/\[Prompted on:.*?\]/g, "").replace(/\[turn: continue\]/g, "").replace(/\[turn: finish\]/g, "").replace(/\[TOOL RESULTS\]/g, "").replace(/\[tool results\]/g, "").substring(0, AGENT_CONTEXT_LENGTH)}`;
       if (agentRes.length > AGENT_CONTEXT_LENGTH) {
         agentRes += "\n... (truncated) ...";
       }
@@ -4038,7 +4027,7 @@ ${originalTextProcessed.length > USER_CONTEXT_LENGTH ? "... (truncated) ...\n\n"
       let match;
       while ((match = toolRegex.exec(text)) !== null) {
         const before = text.substring(lastIdx, match.index);
-        result += stripThoughts ? before.replace(/<think>[\s\S]*?(?:<\/think>|$)/gi, "") : before;
+        result += stripThoughts ? before.replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\]|$)/gi, "") : before;
         const startIdx = match.index + match[0].length - 1;
         let balance = 0;
         let inString = null;
@@ -4078,7 +4067,7 @@ ${originalTextProcessed.length > USER_CONTEXT_LENGTH ? "... (truncated) ...\n\n"
         }
       }
       if (lastIdx < text.length) {
-        result += stripThoughts ? text.substring(lastIdx).replace(/<think>[\s\S]*?(?:<\/think>|$)/gi, "") : text.substring(lastIdx);
+        result += stripThoughts ? text.substring(lastIdx).replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\]|$)/gi, "") : text.substring(lastIdx);
       }
       return result;
     };
@@ -4330,7 +4319,7 @@ ${thinkingLevel != "Fast" ? "[SYSTEM] **STRICTLY FOLLOW THINKING POLICY AS CORE
         let wasToolCalledInLastLoop = false;
         modifiedHistory.forEach((msg) => {
           if (msg.text && msg.role === "agent") {
-            msg.text = msg.text.replace(/<(think|thought)>[\s\S]*?<\/(think|thought)>/gi, "").trim();
+            msg.text = msg.text.replace(/(?:<(think|thought)>|\[(think|thought)\])[\s\S]*?(?:<\/(think|thought)>|\[\/(think|thought)\])/gi, "").trim();
           }
         });
         for (let loop = 0; loop <= MAX_LOOPS; loop++) {
@@ -4479,8 +4468,8 @@ ${thinkingLevel != "Fast" ? "[SYSTEM] **STRICTLY FOLLOW THINKING POLICY AS CORE
                       }
                       const cleanText = dedupeBuffer.substring(overlapLen);
                       if (cleanText) {
-                        const hasOpenThink = /<(think|thought)>(?:(?!<\/(?:think|thought)>)[\s\S])*$/i.test(accumulatedContext);
-                        const dedupeClean = hasOpenThink ? cleanText.replace(/^\s*<(think|thought)>\s*/gi, "") : cleanText.replace(/^\s*<(think|thought)>[\s\S]*?<\/(think|thought)>\s*/gi, "").replace(/^\s*<(think|thought)>\s*/gi, "");
+                        const hasOpenThink = /(?:<(think|thought)>|\[(think|thought)\])(?:(?!(?:<\/(?:think|thought)>|\[\/(?:think|thought)\]))[\s\S])*$/i.test(accumulatedContext);
+                        const dedupeClean = hasOpenThink ? cleanText.replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])\s*/gi, "") : cleanText.replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])[\s\S]*?(?:<\/(think|thought)>|\[\/(think|thought)\])\s*/gi, "").replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])\s*/gi, "");
                         if (dedupeClean) {
                           turnText += dedupeClean;
                           yield { type: "text", content: dedupeClean };
@@ -4564,7 +4553,7 @@ ${thinkingLevel != "Fast" ? "[SYSTEM] **STRICTLY FOLLOW THINKING POLICY AS CORE
                     }
                   }
                   const contextSafeText = getContextSafeText(turnText, false);
-                  const thinkBlocks = contextSafeText.match(/<think>([\s\S]*?)(?:<\/think>|$)/gi) || [];
+                  const thinkBlocks = contextSafeText.match(/(?:<think>|\[think\])([\s\S]*?)(?:<\/think>|\[\/think\]|$)/gi) || [];
                   const thinkContent = thinkBlocks.join("").trim();
                   const sentences = thinkContent.split(/[.!?]\s+/);
                   const uniqueSentences = new Set(sentences);
@@ -4573,11 +4562,11 @@ ${thinkingLevel != "Fast" ? "[SYSTEM] **STRICTLY FOLLOW THINKING POLICY AS CORE
                   let repetitionThresholdThinking = 0.4;
                   let repetitionThresholdResponse = 0.6;
                   const thinkingCaps = {
-                    "low": 200,
-                    "medium": 500,
-                    "high": 2e3,
-                    "max": 3500,
-                    "xhigh": 3500
+                    "low": 256,
+                    "medium": 768,
+                    "high": 2048,
+                    "max": 4096,
+                    "xhigh": 4096
                   };
                   const cap = thinkingCaps[thinkingLevel?.toLowerCase()] || 2500;
                   let isOverVerboseThinking = wordCount > cap;
@@ -4650,7 +4639,7 @@ ${thinkingLevel != "Fast" ? "[SYSTEM] **STRICTLY FOLLOW THINKING POLICY AS CORE
                     await new Promise((resolve) => setTimeout(resolve, 3e3));
                     break;
                   }
-                  const toolActionableText = turnText.replace(/<think>[\s\S]*?(?:<\/think>|$)/gi, "");
+                  const toolActionableText = turnText.replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\]|$)/gi, "");
                   const allToolsFound = detectToolCalls(toolActionableText);
                   while (allToolsFound.length > toolCallPointer) {
                     const toolCall = allToolsFound[toolCallPointer];
@@ -4863,8 +4852,8 @@ ${boxBottom}` };
                 }
                 const cleanText = dedupeBuffer.substring(overlapLen);
                 if (cleanText) {
-                  const hasOpenThink = /<(think|thought)>(?:(?!<\/(?:think|thought)>)[\s\S])*$/i.test(accumulatedContext);
-                  const dedupeClean = hasOpenThink ? cleanText.replace(/^\s*<(think|thought)>\s*/gi, "") : cleanText.replace(/^\s*<(think|thought)>[\s\S]*?<\/(think|thought)>\s*/gi, "").replace(/^\s*<(think|thought)>\s*/gi, "");
+                  const hasOpenThink = /(?:<(think|thought)>|\[(think|thought)\])(?:(?!(?:<\/(?:think|thought)>|\[\/(?:think|thought)\]))[\s\S])*$/i.test(accumulatedContext);
+                  const dedupeClean = hasOpenThink ? cleanText.replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])\s*/gi, "") : cleanText.replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])[\s\S]*?(?:<\/(think|thought)>|\[\/(think|thought)\])\s*/gi, "").replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])\s*/gi, "");
                   if (dedupeClean) {
                     turnText += dedupeClean;
                     yield { type: "text", content: dedupeClean };
@@ -4878,7 +4867,7 @@ ${boxBottom}` };
               const hasFinish2 = /\[\s*(turn\s*:)?\s*finish\s*\]/i.test(signalSafeText2.toLowerCase());
               const hasContinue = /\[\s*(turn\s*:)?\s*continue\s*\]/i.test(signalSafeText2.toLowerCase());
               const didCallTool = toolResults.length > 0 || lastToolSniffed !== null;
-              const pureOutputText = signalSafeText2.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+              const pureOutputText = signalSafeText2.replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\])/gi, "").trim();
               const endsNormally = /[.!?}"'`’“”]$|```$/s.test(pureOutputText);
               if (!hasFinish2 && !hasContinue && !didCallTool && signalSafeText2.length > 0 && !endsNormally && !isThinkingLoop && !isStutteringLoop && !isGeneralLoop) {
                 throw new Error("Silent stream cutoff (500): Model stream closed cleanly but cut off mid-sentence without signals.");
@@ -4902,8 +4891,8 @@ ${boxBottom}` };
                 }
                 const cleanText = dedupeBuffer.substring(overlapLen);
                 if (cleanText) {
-                  const hasOpenThink = /<(think|thought)>(?:(?!<\/(?:think|thought)>)[\s\S])*$/i.test(accumulatedContext);
-                  const dedupeClean = hasOpenThink ? cleanText.replace(/^\s*<(think|thought)>\s*/gi, "") : cleanText.replace(/^\s*<(think|thought)>[\s\S]*?<\/(think|thought)>\s*/gi, "").replace(/^\s*<(think|thought)>\s*/gi, "");
+                  const hasOpenThink = /(?:<(think|thought)>|\[(think|thought)\])(?:(?!(?:<\/(?:think|thought)>|\[\/(?:think|thought)\]))[\s\S])*$/i.test(accumulatedContext);
+                  const dedupeClean = hasOpenThink ? cleanText.replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])\s*/gi, "") : cleanText.replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])[\s\S]*?(?:<\/(think|thought)>|\[\/(think|thought)\])\s*/gi, "").replace(/^\s*(?:<(think|thought)>|\[(think|thought)\])\s*/gi, "");
                   if (dedupeClean) {
                     turnText += dedupeClean;
                   }
@@ -4988,9 +4977,9 @@ Error Log can be found in ${path15.join(LOGS_DIR, "agent", "error.log")}`);
           }
           fullAgentResponseChunks.push(turnText);
           let textToProcess = turnText;
-          const thinkMatch = turnText.match(/<think>([\s\S]*?)<\/think>/i);
+          const thinkMatch = turnText.match(/(?:<think>|\[think\])([\s\S]*?)(?:<\/think>|\[\/think\])/i);
           if (thinkMatch) {
-            textToProcess = turnText.replace(/<think>[\s\S]*?<\/think>/i, "");
+            textToProcess = turnText.replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\])/i, "");
           }
           const signalSafeText = getSanitizedText(turnText);
           const hasFinish = /\[\s*(turn\s*:)?\s*finish\s*\]/i.test(signalSafeText.toLowerCase());
@@ -5000,7 +4989,7 @@ Error Log can be found in ${path15.join(LOGS_DIR, "agent", "error.log")}`);
           let isActuallyFinished = hasFinish && !shouldContinue;
           if (isActuallyFinished) {
             const fullAgentTextRaw = fullAgentResponseChunks.join("\n");
-            const cleanedFullResponse = fullAgentTextRaw.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+            const cleanedFullResponse = fullAgentTextRaw.replace(/(?:<think>|\[think\])[\s\S]*?(?:<\/think>|\[\/think\])/g, "").trim();
             yield {
               type: "interactive_turn_finished",
               data: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "fluxflow-cli",
-	"version": "1.14.5",
+	"version": "1.15.0",
 	"date": "2026-05-26",
 	"description": "A high-fidelity agentic terminal assistant for the Flux Era.",
 	"keywords": [