fix: add minimum budget guard to prevent wasted LLM calls near timeout

When earlier pipeline stages consume most of the timeout budget, later
stages and ReAct loop steps start with insufficient time, virtually
guaranteeing a mid-call timeout that still bills a full LLM request.

Changes:
- Runner: skip step when remaining budget < 8s (step > 0 only)
- Orchestrator: skip stage when remaining budget < 15s (index > 0 only)
- First step/stage always runs regardless of budget size, so small
  overall timeouts still work for simple pipelines and tests

Author: ZhuLinsen

src/agent/orchestrator.py

@@ -307,11 +307,28 @@ def _execute_pipeline(
         specialist_agents_inserted = False
         index = 0
 
+        # Minimum seconds required for a stage to do useful work.  Starting
+        # a stage with less budget virtually guarantees a timeout that wastes
+        # an LLM billing cycle.  Only enforced after at least one stage has
+        # completed so that the first stage always gets a chance to run
+        # even when the total budget is small.
+        _MIN_STAGE_BUDGET_S = 15
+
         while index < len(agents):
             agent = agents[index]
             elapsed_s = time.time() - t0
-            if timeout_s and elapsed_s >= timeout_s:
-                logger.error("[Orchestrator] pipeline timed out before stage '%s'", agent.agent_name)
+            remaining_budget = timeout_s - elapsed_s if timeout_s else None
+            budget_exhausted = (
+                timeout_s
+                and remaining_budget is not None
+                and (
+                    remaining_budget <= 0
+                    or (index > 0 and remaining_budget < _MIN_STAGE_BUDGET_S)
+                )
+            )
+            if budget_exhausted:
+                reason = "timed out" if remaining_budget <= 0 else f"insufficient budget ({remaining_budget:.1f}s < {_MIN_STAGE_BUDGET_S}s)"
+                logger.error("[Orchestrator] pipeline %s before stage '%s'", reason, agent.agent_name)
                 if progress_callback:
                     progress_callback({
                         "type": "pipeline_timeout",

src/agent/runner.py

@@ -370,10 +370,32 @@ def run_agent_loop(
     provider_used = ""
     models_used: List[str] = []
 
+    # Minimum seconds needed for a meaningful LLM round-trip.  If the
+    # remaining budget is positive but below this threshold, the step will
+    # almost certainly timeout mid-call, wasting a billed request.  Only
+    # enforced from step 2 onwards so the first step always gets a chance
+    # even when the total budget is small.
+    _MIN_STEP_BUDGET_S = 8.0
+
     for step in range(max_steps):
         remaining_timeout = _remaining_timeout_seconds(start_time, max_wall_clock_seconds)
-        if remaining_timeout is not None and remaining_timeout <= 0:
-            logger.warning("Agent timed out before step %d", step + 1)
+        budget_exhausted = (
+            remaining_timeout is not None
+            and (
+                remaining_timeout <= 0
+                or (step > 0 and remaining_timeout <= _MIN_STEP_BUDGET_S)
+            )
+        )
+        if budget_exhausted:
+            if remaining_timeout <= 0:
+                logger.warning("Agent timed out before step %d", step + 1)
+            else:
+                logger.warning(
+                    "Agent budget too low for step %d (%.1fs remaining, min %.1fs) — treating as timeout",
+                    step + 1,
+                    remaining_timeout,
+                    _MIN_STEP_BUDGET_S,
+                )
             return _build_timeout_result(
                 start_time=start_time,
                 max_wall_clock_seconds=float(max_wall_clock_seconds),