attocode 0.2.2 → 0.2.4

package/dist/src/integrations/economics.js

@@ -44,6 +44,13 @@ const DOOM_LOOP_PROMPT = (tool, count) => `[System] You've called ${tool} with t
 1. Try a DIFFERENT approach or tool
 2. If blocked, explain what's preventing progress
 3. If the task is complete, say so explicitly`;
+/**
+ * Global doom loop prompt - injected when the same tool call is repeated across multiple workers.
+ */
+const GLOBAL_DOOM_LOOP_PROMPT = (tool, workerCount, totalCalls) => `[System] GLOBAL DOOM LOOP: ${totalCalls} calls to ${tool} across ${workerCount} workers. The entire swarm is stuck on this approach.
+1. Try a fundamentally different strategy
+2. Do NOT retry the same tool/parameters
+3. Consider whether the task goal itself needs re-evaluation`;
 /**
  * Exploration saturation prompt - gentle nudge to start making edits.
  */
@@ -62,6 +69,30 @@ Do not retry the same fix. Try a new approach.`;
 /**
  * Phase budget exploration exceeded prompt.
  */
+/** Detect bash commands that are doing file write operations (write/append/redirect/heredoc). */
+const BASH_FILE_WRITE_RE = /^\s*(cat|echo|printf)\b.*(?:>>?|<<)\s*/;
+/** Check whether a bash command is attempting file operations that should use dedicated tools. */
+function isBashFileOperation(command) {
+    return BASH_FILE_READ_RE.test(command) || BASH_FILE_WRITE_RE.test(command) || /heredoc|EOF/i.test(command);
+}
+const BASH_FAILURE_CASCADE_PROMPT = (failures, lastCommand) => {
+    const isFileOp = lastCommand && isBashFileOperation(lastCommand);
+    if (isFileOp) {
+        return `[System] ${failures} consecutive bash commands have failed trying to do file operations.
+STOP using bash for file operations. Use the correct tool:
+- To CREATE a file: write_file (not cat/echo with redirect)
+- To MODIFY a file: edit_file (not sed/awk)
+- To READ a file: read_file (not cat/head/tail)
+Switch to the correct tool NOW.`;
+    }
+    return `[System] ${failures} consecutive bash commands have failed. STOP and:
+1. Explain what you're trying to accomplish
+2. Try a DIFFERENT approach or tool
+3. Do not run another bash command with the same pattern`;
+};
+const SUMMARY_LOOP_PROMPT = `[System] You've produced text-only responses without using tools. You should be DOING work, not summarizing it.
+Pick the most important remaining task and start working on it NOW using your tools (write_file, edit_file, bash, etc.).
+Do NOT output another status summary or task list.`;
 const EXPLORATION_BUDGET_EXCEEDED_PROMPT = (pct) => `[System] You've spent ${pct}% of your iterations in exploration. Start making edits NOW.
 Do not read more files. Use what you know to make the fix.`;
 /**
@@ -69,6 +100,41 @@ Do not read more files. Use what you know to make the fix.`;
  */
 const VERIFICATION_RESERVE_PROMPT = `[System] You are running low on iterations. Run your tests NOW to verify your changes.
 Do not make more edits until you've confirmed whether the current fix works.`;
+const BUDGET_ADVISORY_PROMPT = (reason) => `[System] Budget advisory (${reason}) detected. Continue execution and focus on concrete tool actions to complete the task.`;
+/**
+ * Extract success and output from a bash tool result.
+ * In production, bash results are objects `{ success, output, metadata }`.
+ * Tests may pass strings directly. This normalizes both.
+ */
+export function extractBashResult(result) {
+    if (result && typeof result === 'object') {
+        const obj = result;
+        return {
+            success: obj.success !== false,
+            output: typeof obj.output === 'string' ? obj.output : '',
+        };
+    }
+    if (typeof result === 'string') {
+        return { success: true, output: result };
+    }
+    return { success: true, output: '' };
+}
+/**
+ * Regex for common bash file-read commands (simple, no pipes/redirects).
+ * Captures the file path for normalized doom loop fingerprinting.
+ */
+const BASH_FILE_READ_RE = /^\s*(cat|head|tail|wc|less|more|file|stat|md5sum|sha256sum)\b(?:\s+-[^\s]+)*\s+((?:\/|\.\/|\.\.\/)[\w.\/\-@]+|[\w.\-@][\w.\/\-@]*)\s*$/;
+/**
+ * Extract the file target from a simple bash file-read command.
+ * Returns null for complex commands (pipes, redirects, non-file-read commands).
+ * Used to normalize doom loop fingerprints across cat/head/tail/wc targeting the same file.
+ */
+export function extractBashFileTarget(command) {
+    if (/[|;&<>]/.test(command))
+        return null; // pipes/redirects = complex, skip
+    const match = command.match(BASH_FILE_READ_RE);
+    return match ? match[2] : null;
+}
 /**
  * Primary argument keys that identify the *target* of a tool call.
  * Used for fuzzy doom loop detection — ignoring secondary/optional args.
@@ -83,6 +149,13 @@ const PRIMARY_KEYS = ['path', 'file_path', 'command', 'pattern', 'query', 'url',
 export function computeToolFingerprint(toolName, argsStr) {
     try {
         const args = JSON.parse(argsStr || '{}');
+        // W1: Normalize bash file-read commands so cat/head/tail/wc targeting the same file
+        // produce the same fingerprint, triggering doom loop detection.
+        if (toolName === 'bash' && typeof args.command === 'string') {
+            const fileTarget = extractBashFileTarget(args.command);
+            if (fileTarget)
+                return `bash:file_read:${fileTarget}`;
+        }
         const primaryArgs = {};
         for (const key of PRIMARY_KEYS) {
             if (key in args) {
@@ -115,8 +188,17 @@ export class ExecutionEconomicsManager {
     pauseStart = null;
     listeners = [];
     extensionHandler;
-    constructor(budget) {
+    // Shared economics state for cross-worker doom loop aggregation
+    sharedEconomics;
+    workerId;
+    // Adaptive budget: stores original maxIterations for reversible reduction
+    originalMaxIterations = null;
+    constructor(budget, sharedEconomics, workerId) {
+        this.sharedEconomics = sharedEconomics ?? null;
+        this.workerId = workerId ?? 'root';
+        const tuning = budget?.tuning;
         this.budget = {
+            enforcementMode: budget?.enforcementMode ?? 'strict',
             // Hard limits
             maxTokens: budget?.maxTokens ?? 200000,
             maxCost: budget?.maxCost ?? 1.00,
@@ -128,6 +210,8 @@ export class ExecutionEconomicsManager {
             // Iteration guidance
             targetIterations: budget?.targetIterations ?? 20,
             maxIterations: budget?.maxIterations ?? 100,
+            // Tuning
+            tuning,
         };
         this.usage = {
             tokens: 0,
@@ -147,13 +231,13 @@ export class ExecutionEconomicsManager {
             lastMeaningfulProgress: Date.now(),
             stuckCount: 0,
         };
-        // Initialize doom loop detection state
+        // Initialize doom loop detection state (thresholds configurable via tuning)
         this.loopState = {
             doomLoopDetected: false,
             lastTool: null,
             consecutiveCount: 0,
-            threshold: 3,
-            fuzzyThreshold: 4,
+            threshold: tuning?.doomLoopThreshold ?? 3,
+            fuzzyThreshold: tuning?.doomLoopFuzzyThreshold ?? (tuning?.doomLoopThreshold ? tuning.doomLoopThreshold + 1 : 4),
             lastWarningTime: 0,
         };
         // Initialize phase tracking state
@@ -170,6 +254,8 @@ export class ExecutionEconomicsManager {
             lastTestPassed: null,
             consecutiveTestFailures: 0,
             inTestFixCycle: false,
+            consecutiveBashFailures: 0,
+            consecutiveTextOnlyTurns: 0,
         };
         this.startTime = Date.now();
     }
@@ -235,12 +321,21 @@ export class ExecutionEconomicsManager {
         // Update duration
         this.usage.duration = this.getEffectiveDuration();
     }
+    /**
+     * Record a text-only turn (LLM response with no tool calls).
+     * Increments the consecutive text-only turn counter for summary-loop detection.
+     */
+    recordTextOnlyTurn() {
+        this.phaseState.consecutiveTextOnlyTurns++;
+    }
     /**
      * Record a tool call for progress tracking and loop detection.
      */
     recordToolCall(toolName, args, _result) {
         this.usage.toolCalls++;
         this.usage.iterations++;
+        // Any tool call resets the text-only turn counter
+        this.phaseState.consecutiveTextOnlyTurns = 0;
         const now = Date.now();
         // Track for loop detection (stableStringify ensures consistent ordering for comparison)
         const argsStr = stableStringify(args);
@@ -253,6 +348,11 @@ export class ExecutionEconomicsManager {
         // DOOM LOOP DETECTION (OpenCode pattern)
         // =========================================================================
         this.updateDoomLoopState(toolName, argsStr);
+        // Report to shared economics for cross-worker doom loop aggregation
+        if (this.sharedEconomics) {
+            const fingerprint = computeToolFingerprint(toolName, argsStr);
+            this.sharedEconomics.recordToolCall(this.workerId, fingerprint);
+        }
         // =========================================================================
         // PHASE TRACKING
         // =========================================================================
@@ -293,6 +393,17 @@ export class ExecutionEconomicsManager {
             this.progress.commandsRun.push(command);
             this.progress.lastMeaningfulProgress = now;
             this.progress.stuckCount = 0;
+            // Extract result from bash tool output (object or string)
+            const bashResult = extractBashResult(_result);
+            // Track consecutive bash failures (any bash command, not just tests)
+            if (_result !== undefined) {
+                if (!bashResult.success) {
+                    this.phaseState.consecutiveBashFailures++;
+                }
+                else {
+                    this.phaseState.consecutiveBashFailures = 0;
+                }
+            }
             // Detect test runs and track outcomes
             if (command.includes('test') || command.includes('pytest') || command.includes('npm test') || command.includes('jest')) {
                 this.phaseState.testsRun++;
@@ -300,10 +411,9 @@ export class ExecutionEconomicsManager {
                 if (this.phaseState.phase === 'acting' && this.phaseState.filesModified.size > 0) {
                     this.transitionPhase('verifying', 'Tests run after edits');
                 }
-                // Track test pass/fail from result if available
-                if (_result !== undefined) {
-                    const resultStr = typeof _result === 'string' ? _result : '';
-                    this.parseTestOutcome(command, resultStr);
+                // Fix: extract output from result object, not treat as string
+                if (bashResult.output) {
+                    this.parseTestOutcome(command, bashResult.output);
                 }
             }
         }
@@ -416,8 +526,9 @@ export class ExecutionEconomicsManager {
             this.phaseState.shouldTransition = false;
             return;
         }
-        // After reading 10+ unique files without edits, suggest transition
-        if (uniqueFilesRead.size >= 10 && filesModified.size === 0) {
+        // After N+ unique files without edits, suggest transition (configurable, default: 10)
+        const fileThreshold = this.budget.tuning?.explorationFileThreshold ?? 10;
+        if (uniqueFilesRead.size >= fileThreshold && filesModified.size === 0) {
             this.phaseState.shouldTransition = true;
             this.emit({
                 type: 'exploration.saturation',
@@ -426,8 +537,9 @@ export class ExecutionEconomicsManager {
             });
             return;
         }
-        // After 5+ iterations in exploration with diminishing returns (< 2 new files)
-        if (iterationsInPhase >= 5 && recentNewFiles < 2 && filesModified.size === 0) {
+        // After N+ iterations in exploration with diminishing returns (configurable, default: 15)
+        const iterThreshold = this.budget.tuning?.explorationIterThreshold ?? 15;
+        if (iterationsInPhase >= iterThreshold && recentNewFiles < 2 && filesModified.size === 0) {
             this.phaseState.shouldTransition = true;
             this.emit({
                 type: 'exploration.saturation',
@@ -443,9 +555,22 @@ export class ExecutionEconomicsManager {
      */
     checkBudget() {
         this.usage.duration = this.getEffectiveDuration();
+        const strictBudgetEnforcement = (this.budget.enforcementMode ?? 'strict') === 'strict';
         // Check hard limits first
         if (this.usage.tokens >= this.budget.maxTokens) {
             this.emit({ type: 'budget.exceeded', budgetType: 'tokens', limit: this.budget.maxTokens, actual: this.usage.tokens });
+            if (!strictBudgetEnforcement) {
+                return {
+                    canContinue: true,
+                    reason: `Token budget exceeded (${this.usage.tokens.toLocaleString()} / ${this.budget.maxTokens.toLocaleString()})`,
+                    budgetType: 'tokens',
+                    isHardLimit: false,
+                    isSoftLimit: true,
+                    percentUsed: (this.usage.tokens / this.budget.maxTokens) * 100,
+                    suggestedAction: 'warn',
+                    injectedPrompt: BUDGET_ADVISORY_PROMPT('tokens'),
+                };
+            }
             return {
                 canContinue: false,
                 reason: `Token budget exceeded (${this.usage.tokens.toLocaleString()} / ${this.budget.maxTokens.toLocaleString()})`,
@@ -458,6 +583,18 @@ export class ExecutionEconomicsManager {
         }
         if (this.usage.cost >= this.budget.maxCost) {
             this.emit({ type: 'budget.exceeded', budgetType: 'cost', limit: this.budget.maxCost, actual: this.usage.cost });
+            if (!strictBudgetEnforcement) {
+                return {
+                    canContinue: true,
+                    reason: `Cost budget exceeded ($${this.usage.cost.toFixed(2)} / $${this.budget.maxCost.toFixed(2)})`,
+                    budgetType: 'cost',
+                    isHardLimit: false,
+                    isSoftLimit: true,
+                    percentUsed: (this.usage.cost / this.budget.maxCost) * 100,
+                    suggestedAction: 'warn',
+                    injectedPrompt: BUDGET_ADVISORY_PROMPT('cost'),
+                };
+            }
             return {
                 canContinue: false,
                 reason: `Cost budget exceeded ($${this.usage.cost.toFixed(2)} / $${this.budget.maxCost.toFixed(2)})`,
@@ -470,6 +607,18 @@ export class ExecutionEconomicsManager {
         }
         if (this.usage.duration >= this.budget.maxDuration) {
             this.emit({ type: 'budget.exceeded', budgetType: 'duration', limit: this.budget.maxDuration, actual: this.usage.duration });
+            if (!strictBudgetEnforcement) {
+                return {
+                    canContinue: true,
+                    reason: `Duration limit exceeded (${Math.round(this.usage.duration / 1000)}s / ${Math.round(this.budget.maxDuration / 1000)}s)`,
+                    budgetType: 'duration',
+                    isHardLimit: false,
+                    isSoftLimit: true,
+                    percentUsed: (this.usage.duration / this.budget.maxDuration) * 100,
+                    suggestedAction: 'warn',
+                    injectedPrompt: BUDGET_ADVISORY_PROMPT('duration'),
+                };
+            }
             return {
                 canContinue: false,
                 reason: `Duration limit exceeded (${Math.round(this.usage.duration / 1000)}s / ${Math.round(this.budget.maxDuration / 1000)}s)`,
@@ -480,10 +629,13 @@ export class ExecutionEconomicsManager {
                 suggestedAction: 'stop',
             };
         }
-        // Max iterations reached - allow one more turn for summary (forceTextOnly)
+        // Max iterations reached — allow exactly ONE more turn for summary, then terminate.
+        // First time at maxIterations: canContinue=true + forceTextOnly for a clean summary.
+        // Beyond maxIterations: canContinue=false to stop the loop.
         if (this.usage.iterations >= this.budget.maxIterations) {
+            const isFirstOverage = this.usage.iterations === this.budget.maxIterations;
             return {
-                canContinue: true, // Allow one more turn for summary
+                canContinue: isFirstOverage, // Only allow one summary turn
                 reason: `Maximum iterations reached (${this.usage.iterations} / ${this.budget.maxIterations})`,
                 budgetType: 'iterations',
                 isHardLimit: true,
@@ -495,6 +647,50 @@ export class ExecutionEconomicsManager {
             };
         }
         // =========================================================================
+        // ZERO PROGRESS DETECTION — nudge workers making no tool calls (D1)
+        // Raised threshold to 10 (from 5) to give agents more time to plan.
+        // No longer forces text-only — instead injects a strong nudge while
+        // still allowing tool calls so the agent can recover.
+        // =========================================================================
+        const zeroProgressThreshold = this.budget.tuning?.zeroProgressThreshold ?? 10;
+        if (this.usage.iterations >= zeroProgressThreshold && this.usage.toolCalls === 0) {
+            // Only force text-only after 2x the threshold (complete stall)
+            const isCompleteStall = this.usage.iterations >= zeroProgressThreshold * 2;
+            return {
+                canContinue: true,
+                reason: `Zero tool calls in ${this.usage.iterations} iterations`,
+                budgetType: 'iterations',
+                isHardLimit: false,
+                isSoftLimit: true,
+                percentUsed: (this.usage.iterations / this.budget.maxIterations) * 100,
+                suggestedAction: isCompleteStall ? 'stop' : 'warn',
+                forceTextOnly: isCompleteStall,
+                injectedPrompt: `[System] WARNING: You have completed ${this.usage.iterations} iterations without making a single tool call. ` +
+                    `You MUST use your tools (read_file, write_file, grep, bash, etc.) to accomplish your task. ` +
+                    `Start by reading a relevant file or running a command NOW.` +
+                    (isCompleteStall ? ` This is your LAST chance — respond with a summary if you cannot proceed.` : ''),
+            };
+        }
+        // =========================================================================
+        // ADAPTIVE ITERATION BUDGET — reversible reduction at checkpoint (D4)
+        // Stores original maxIterations so it can be restored if tools resume.
+        // =========================================================================
+        const checkpoint = this.budget.tuning?.progressCheckpoint ?? 10;
+        if (this.usage.iterations === checkpoint && this.usage.toolCalls === 0) {
+            if (!this.originalMaxIterations) {
+                this.originalMaxIterations = this.budget.maxIterations;
+            }
+            const reducedMax = checkpoint + 5; // give 5 more iterations (up from 3)
+            if (this.budget.maxIterations > reducedMax) {
+                this.budget.maxIterations = reducedMax;
+            }
+        }
+        // Restore original maxIterations if tools start being used after reduction
+        if (this.originalMaxIterations && this.usage.toolCalls > 0 && this.budget.maxIterations < this.originalMaxIterations) {
+            this.budget.maxIterations = this.originalMaxIterations;
+            this.originalMaxIterations = null;
+        }
+        // =========================================================================
         // DOOM LOOP DETECTION - Strong intervention
         // =========================================================================
         if (this.loopState.doomLoopDetected) {
@@ -510,6 +706,26 @@ export class ExecutionEconomicsManager {
             };
         }
         // =========================================================================
+        // GLOBAL DOOM LOOP DETECTION - Cross-worker stuck pattern
+        // =========================================================================
+        if (this.sharedEconomics && this.progress.recentToolCalls.length > 0) {
+            const lastCall = this.progress.recentToolCalls[this.progress.recentToolCalls.length - 1];
+            const fingerprint = computeToolFingerprint(lastCall.tool, lastCall.args);
+            if (this.sharedEconomics.isGlobalDoomLoop(fingerprint)) {
+                const info = this.sharedEconomics.getGlobalLoopInfo(fingerprint);
+                return {
+                    canContinue: true,
+                    reason: `Global doom loop: ${lastCall.tool} repeated across ${info?.workerCount ?? 0} workers`,
+                    budgetType: 'iterations',
+                    isHardLimit: false,
+                    isSoftLimit: true,
+                    percentUsed: (this.usage.iterations / this.budget.targetIterations) * 100,
+                    suggestedAction: 'warn',
+                    injectedPrompt: GLOBAL_DOOM_LOOP_PROMPT(lastCall.tool, info?.workerCount ?? 0, info?.count ?? 0),
+                };
+            }
+        }
+        // =========================================================================
         // EXPLORATION SATURATION - Gentle nudge
         // =========================================================================
         if (this.phaseState.shouldTransition) {
@@ -540,6 +756,54 @@ export class ExecutionEconomicsManager {
             };
         }
         // =========================================================================
+        // BASH FAILURE CASCADE - Strong intervention after 3+ consecutive failures
+        // =========================================================================
+        if (this.phaseState.consecutiveBashFailures >= 3) {
+            // Extract last bash command for tool-aware remediation
+            let lastBashCommand;
+            for (let i = this.progress.recentToolCalls.length - 1; i >= 0; i--) {
+                if (this.progress.recentToolCalls[i].tool === 'bash') {
+                    try {
+                        const parsed = JSON.parse(this.progress.recentToolCalls[i].args);
+                        lastBashCommand = parsed.command;
+                    }
+                    catch { /* ignore parse errors */ }
+                    break;
+                }
+            }
+            return {
+                canContinue: true,
+                reason: `${this.phaseState.consecutiveBashFailures} consecutive bash failures`,
+                budgetType: 'iterations',
+                isHardLimit: false,
+                isSoftLimit: true,
+                percentUsed: (this.usage.iterations / this.budget.targetIterations) * 100,
+                suggestedAction: 'warn',
+                injectedPrompt: BASH_FAILURE_CASCADE_PROMPT(this.phaseState.consecutiveBashFailures, lastBashCommand),
+            };
+        }
+        // =========================================================================
+        // SUMMARY LOOP DETECTION - Nudge after 2+ consecutive text-only turns
+        // Skip when close to budget limit — the agent can't "start working" if
+        // forceTextOnly would be set on the next check (contradictory nudge).
+        // =========================================================================
+        if (this.phaseState.consecutiveTextOnlyTurns >= 2) {
+            const nearBudgetLimit = this.usage.iterations >= this.budget.maxIterations - 1;
+            if (!nearBudgetLimit) {
+                return {
+                    canContinue: true,
+                    reason: `${this.phaseState.consecutiveTextOnlyTurns} consecutive text-only turns (summary loop)`,
+                    budgetType: 'iterations',
+                    isHardLimit: false,
+                    isSoftLimit: true,
+                    percentUsed: (this.usage.iterations / this.budget.targetIterations) * 100,
+                    suggestedAction: 'warn',
+                    injectedPrompt: SUMMARY_LOOP_PROMPT,
+                };
+            }
+            // Near budget limit: skip nudge, let MAX_STEPS_PROMPT handle it next turn
+        }
+        // =========================================================================
         // PHASE-AWARE BUDGET ALLOCATION (opt-in, used in eval mode)
         // =========================================================================
         if (this.phaseBudget?.enabled) {
@@ -716,7 +980,9 @@ export class ExecutionEconomicsManager {
         const budget = this.budget;
         const tokenPct = Math.round((usage.tokens / budget.maxTokens) * 100);
         const remainingTokens = budget.maxTokens - usage.tokens;
-        const remainingSec = Math.max(0, Math.round((budget.maxDuration - usage.duration) / 1000));
+        const remainingSec = budget.maxDuration === Infinity
+            ? Infinity
+            : Math.max(0, Math.round((budget.maxDuration - usage.duration) / 1000));
         // Determine urgency level
         let urgency = '';
         if (tokenPct >= 90) {
@@ -725,7 +991,8 @@ export class ExecutionEconomicsManager {
         else if (tokenPct >= 70) {
             urgency = '⚡ WARNING: ';
         }
-        return `${urgency}Budget: ${usage.tokens.toLocaleString()}/${budget.maxTokens.toLocaleString()} tokens (${tokenPct}%), ~${remainingSec}s remaining. ${tokenPct >= 70 ? 'Wrap up soon!' : ''}`.trim();
+        const timeStr = remainingSec === Infinity ? 'no time limit' : `~${remainingSec}s remaining`;
+        return `${urgency}Budget: ${usage.tokens.toLocaleString()}/${budget.maxTokens.toLocaleString()} tokens (${tokenPct}%), ${timeStr}. ${tokenPct >= 70 ? 'Wrap up soon!' : ''}`.trim();
     }
     /**
      * Check if approaching budget limit (for proactive warnings).
@@ -755,6 +1022,12 @@ export class ExecutionEconomicsManager {
             stuckCount: this.progress.stuckCount,
         };
     }
+    /**
+     * Get actual file paths modified during this session.
+     */
+    getModifiedFilePaths() {
+        return [...this.progress.filesModified];
+    }
     /**
      * Get doom loop detection state.
      */
@@ -776,6 +1049,7 @@ export class ExecutionEconomicsManager {
             lastTestPassed: this.phaseState.lastTestPassed,
             consecutiveTestFailures: this.phaseState.consecutiveTestFailures,
             inTestFixCycle: this.phaseState.inTestFixCycle,
+            consecutiveBashFailures: this.phaseState.consecutiveBashFailures,
         };
     }
     /**
@@ -811,13 +1085,14 @@ export class ExecutionEconomicsManager {
             lastMeaningfulProgress: Date.now(),
             stuckCount: 0,
         };
-        // Reset loop detection state
+        // Reset loop detection state (preserve tuning thresholds)
+        const tuning = this.budget.tuning;
         this.loopState = {
             doomLoopDetected: false,
             lastTool: null,
             consecutiveCount: 0,
-            threshold: 3,
-            fuzzyThreshold: 4,
+            threshold: tuning?.doomLoopThreshold ?? 3,
+            fuzzyThreshold: tuning?.doomLoopFuzzyThreshold ?? (tuning?.doomLoopThreshold ? tuning.doomLoopThreshold + 1 : 4),
             lastWarningTime: 0,
         };
         // Reset phase tracking state
@@ -834,10 +1109,13 @@ export class ExecutionEconomicsManager {
             lastTestPassed: null,
             consecutiveTestFailures: 0,
             inTestFixCycle: false,
+            consecutiveBashFailures: 0,
+            consecutiveTextOnlyTurns: 0,
         };
         this.startTime = Date.now();
         this.pausedDuration = 0;
         this.pauseStart = null;
+        this.originalMaxIterations = null;
     }
     // -------------------------------------------------------------------------
     // PRIVATE METHODS
@@ -938,13 +1216,13 @@ export const STANDARD_BUDGET = {
  * and other parallel subagents.
  */
 export const SUBAGENT_BUDGET = {
-    maxTokens: 150000, // 150k tokens (research agents need more room)
-    softTokenLimit: 100000, // Warn at 100k
-    maxCost: 0.50, // Match standard budget
-    maxDuration: 360000, // 6 minutes
-    softDurationLimit: 300000, // Warn at 5 minutes
-    targetIterations: 20,
-    maxIterations: 40,
+    maxTokens: 250000, // 250k tokens — coders need room for explore + code
+    softTokenLimit: 180000, // Warn at 180k
+    maxCost: 0.75, // Increased ceiling for heavier workloads
+    maxDuration: 480000, // 8 minutes
+    softDurationLimit: 420000, // Warn at 7 minutes
+    targetIterations: 30,
+    maxIterations: 60,
 };
 /**
  * Large task budget - for complex multi-step tasks.
@@ -956,6 +1234,23 @@ export const LARGE_BUDGET = {
     targetIterations: 50,
     maxIterations: 200,
 };
+/**
+ * TUI root agent budget - no time limit, high iteration cap.
+ * The TUI root agent must be able to run as long as needed (swarm tasks,
+ * multi-step workflows). Duration is effectively unlimited; token/cost
+ * limits still apply as a safety net.
+ */
+export const TUI_ROOT_BUDGET = {
+    enforcementMode: 'doomloop_only',
+    maxTokens: 500000,
+    softTokenLimit: 400000,
+    maxCost: 5.00,
+    softCostLimit: 4.00,
+    maxDuration: Infinity, // No time limit — run as long as tasks remain
+    softDurationLimit: Infinity,
+    targetIterations: 100,
+    maxIterations: 500,
+};
 /**
  * Unlimited budget - no limits (use with caution).
  */
@@ -971,13 +1266,13 @@ export const UNLIMITED_BUDGET = {
  * Each worker gets a small slice of the total swarm budget.
  */
 export const SWARM_WORKER_BUDGET = {
-    maxTokens: 20000,
-    softTokenLimit: 15000,
-    maxCost: 0.05,
-    maxDuration: 120000, // 2 minutes
-    softDurationLimit: 90000, // Warn at 90s
-    targetIterations: 10,
-    maxIterations: 15,
+    maxTokens: 30000,
+    softTokenLimit: 25000,
+    maxCost: 0.08,
+    maxDuration: 180000, // 3 minutes
+    softDurationLimit: 150000, // Warn at 2.5 min
+    targetIterations: 15,
+    maxIterations: 25,
 };
 /**
  * Swarm orchestrator budget - moderate budget for decomposition and quality gates.