fix: normalize DeepSeek non-standard tool_calls format

Systematic debugging revealed DeepSeek returns tool_calls in non-standard
format that bypasses LangChain's parse_tool_call():

**Root Cause:**
- OpenAI standard: {function: {name, arguments}, id}
- DeepSeek format: {name, args, id}
- LangChain's parse_tool_call() returns None when no 'function' key
- Result: Raw tool_call with string args → Pydantic validation error

**Solution:**
- ToolCallArgsParsingWrapper detects non-standard format
- Normalizes to OpenAI standard before LangChain processing
- Converts {name, args, id} → {function: {name, arguments}, id}
- Added diagnostic logging to identify format variations

**Impact:**
- DeepSeek models now work via OpenRouter
- No breaking changes to other providers (defensive design)
- Diagnostic logs help debug future format issues

Fixes validation errors:
  tool_calls.0.args: Input should be a valid dictionary
  [type=dict_type, input_value='{"symbol": "GILD", ...}', input_type=str]

CHANGELOG.md

@@ -7,7 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.4.0] - 2025-11-04
+### Fixed
+- Fixed Pydantic validation errors when using DeepSeek models via OpenRouter
+- Root cause: DeepSeek returns tool_calls in non-standard format with `args` field directly, bypassing LangChain's `parse_tool_call()`
+- Solution: Added `ToolCallArgsParsingWrapper` that normalizes non-standard tool_call format to OpenAI standard before LangChain processing
+- Wrapper converts `{name, args, id}` → `{function: {name, arguments}, id}` format
+- Includes diagnostic logging to identify format inconsistencies across providers
+
+## [0.4.1] - 2025-11-06
+
+### Fixed
+- Fixed "No trading" message always displaying despite trading activity by initializing `IF_TRADE` to `True` (trades expected by default)
+- Root cause: `IF_TRADE` was initialized to `False` in runtime config but never updated when trades executed
+
+### Note
+- ChatDeepSeek integration was reverted as it conflicts with OpenRouter unified gateway architecture
+- System uses `OPENAI_API_BASE` (OpenRouter) with single `OPENAI_API_KEY` for all providers
+- Sporadic DeepSeek validation errors appear to be transient and do not require code changes
+
+## [0.4.0] - 2025-11-05
 
 ### BREAKING CHANGES
 
@@ -130,6 +148,49 @@ New `/results?reasoning=full` returns:
 - Test coverage increased with 36+ new comprehensive tests
 - Documentation updated with complete API reference and database schema details
 
+### Fixed
+- **Critical:** Intra-day position tracking for sell-then-buy trades (e20dce7)
+  - Sell proceeds now immediately available for subsequent buy orders within same trading session
+  - ContextInjector maintains in-memory position state during trading sessions
+  - Position updates accumulate after each successful trade
+  - Enables agents to rebalance portfolios (sell + buy) in single session
+  - Added 13 comprehensive tests for position tracking
+- **Critical:** Tool message extraction in conversation history (462de3a, abb9cd0)
+  - Fixed bug where tool messages (buy/sell trades) were not captured when agent completed in single step
+  - Tool extraction now happens BEFORE finish signal check
+  - Reasoning summaries now accurately reflect actual trades executed
+  - Resolves issue where summarizer saw 0 tools despite multiple trades
+- Reasoning summary generation improvements (6d126db)
+  - Summaries now explicitly mention specific trades executed (symbols, quantities, actions)
+  - Added TRADES EXECUTED section highlighting tool calls
+  - Example: 'sold 1 GOOGL and 1 AMZN to reduce exposure' instead of 'maintain core holdings'
+- Final holdings calculation accuracy (a8d912b)
+  - Final positions now calculated from actions instead of querying incomplete database records
+  - Correctly handles first trading day with multiple trades
+  - New `_calculate_final_position_from_actions()` method applies all trades to calculate final state
+  - Holdings now persist correctly across all trading days
+  - Added 3 comprehensive tests for final position calculation
+- Holdings persistence between trading days (aa16480)
+  - Query now retrieves previous day's ending position as current day's starting position
+  - Changed query from `date <=` to `date <` to prevent returning incomplete current-day records
+  - Fixes empty starting_position/final_position in API responses despite successful trades
+  - Updated tests to verify correct previous-day retrieval
+- Context injector trading_day_id synchronization (05620fa)
+  - ContextInjector now updated with trading_day_id after record creation
+  - Fixes "Trade failed: trading_day_id not found in runtime config" error
+  - MCP tools now correctly receive trading_day_id via context injection
+- Schema migration compatibility fixes (7c71a04)
+  - Updated position queries to use new trading_days schema instead of obsolete positions table
+  - Removed obsolete add_no_trade_record_to_db function calls
+  - Fixes "no such table: positions" error
+  - Simplified _handle_trading_result logic
+- Database referential integrity (9da65c2)
+  - Corrected Database default path from "data/trading.db" to "data/jobs.db"
+  - Ensures all components use same database file
+  - Fixes FOREIGN KEY constraint failures when creating trading_day records
+- Debug logging cleanup (1e7bdb5)
+  - Removed verbose debug logging from ContextInjector for cleaner output
+
 ## [0.3.1] - 2025-11-03
 
 ### Fixed

ROADMAP.md

@@ -4,6 +4,78 @@ This document outlines planned features and improvements for the AI-Trader proje
 
 ## Release Planning
 
+### v0.5.0 - Performance Metrics & Status APIs (Planned)
+
+**Focus:** Enhanced observability and performance tracking
+
+#### Performance Metrics API
+- **Performance Summary Endpoint** - Query model performance over date ranges
+  - `GET /metrics/performance` - Aggregated performance metrics
+    - Query parameters: `model`, `start_date`, `end_date`
+    - Returns comprehensive performance summary:
+      - Total return (dollar amount and percentage)
+      - Number of trades executed (buy + sell)
+      - Win rate (profitable trading days / total trading days)
+      - Average daily P&L (profit and loss)
+      - Best/worst trading day (highest/lowest daily P&L)
+      - Final portfolio value (cash + holdings at market value)
+      - Number of trading days in queried range
+      - Starting vs. ending portfolio comparison
+    - Use cases:
+      - Compare model performance across different time periods
+      - Evaluate strategy effectiveness
+      - Identify top-performing models
+    - Example: `GET /metrics/performance?model=gpt-4&start_date=2025-01-01&end_date=2025-01-31`
+  - Filtering options:
+    - Single model or all models
+    - Custom date ranges
+    - Exclude incomplete trading days
+  - Response format: JSON with clear metric definitions
+
+#### Status & Coverage Endpoint
+- **System Status Summary** - Data availability and simulation progress
+  - `GET /status` - Comprehensive system status
+    - Price data coverage section:
+      - Available symbols (NASDAQ 100 constituents)
+      - Date range of downloaded price data per symbol
+      - Total trading days with complete data
+      - Missing data gaps (symbols without data, date gaps)
+      - Last data refresh timestamp
+    - Model simulation status section:
+      - List of all configured models (enabled/disabled)
+      - Date ranges simulated per model (first and last trading day)
+      - Total trading days completed per model
+      - Most recent simulation date per model
+      - Completion percentage (simulated days / available data days)
+    - System health section:
+      - Database connectivity status
+      - MCP services status (Math, Search, Trade, LocalPrices)
+      - API version and deployment mode
+      - Disk space usage (database size, log size)
+    - Use cases:
+      - Verify data availability before triggering simulations
+      - Identify which models need updates to latest data
+      - Monitor system health and readiness
+      - Plan data downloads for missing date ranges
+    - Example: `GET /status` (no parameters required)
+  - Benefits:
+    - Single endpoint for complete system overview
+    - No need to query multiple endpoints for status
+    - Clear visibility into data gaps
+    - Track simulation progress across models
+
+#### Implementation Details
+- Database queries for efficient metric calculation
+- Caching for frequently accessed metrics (optional)
+- Response time target: <500ms for typical queries
+- Comprehensive error handling for missing data
+
+#### Benefits
+- **Better Observability** - Clear view of system state and model performance
+- **Data-Driven Decisions** - Quantitative metrics for model comparison
+- **Proactive Monitoring** - Identify data gaps before simulations fail
+- **User Experience** - Single endpoint to check "what's available and what's been done"
+
 ### v1.0.0 - Production Stability & Validation (Planned)
 
 **Focus:** Comprehensive testing, documentation, and production readiness
@@ -607,11 +679,13 @@ To propose a new feature:
 
 - **v0.1.0** - Initial release with batch execution
 - **v0.2.0** - Docker deployment support
-- **v0.3.0** - REST API, on-demand downloads, database storage (current)
+- **v0.3.0** - REST API, on-demand downloads, database storage
+- **v0.4.0** - Daily P&L calculation, day-centric results API, reasoning summaries (current)
+- **v0.5.0** - Performance metrics & status APIs (planned)
 - **v1.0.0** - Production stability & validation (planned)
 - **v1.1.0** - API authentication & security (planned)
 - **v1.2.0** - Position history & analytics (planned)
-- **v1.3.0** - Performance metrics & analytics (planned)
+- **v1.3.0** - Advanced performance metrics & analytics (planned)
 - **v1.4.0** - Data management API (planned)
 - **v1.5.0** - Web dashboard UI (planned)
 - **v1.6.0** - Advanced configuration & customization (planned)
@@ -619,4 +693,4 @@ To propose a new feature:
 
 ---
 
-Last updated: 2025-11-01
+Last updated: 2025-11-06

agent/base_agent/base_agent.py

@@ -33,6 +33,7 @@ from tools.deployment_config import (
 from agent.context_injector import ContextInjector
 from agent.pnl_calculator import DailyPnLCalculator
 from agent.reasoning_summarizer import ReasoningSummarizer
+from agent.chat_model_wrapper import ToolCallArgsParsingWrapper
 
 # Load environment variables
 load_dotenv()
@@ -211,14 +212,16 @@ class BaseAgent:
                 self.model = MockChatModel(date="2025-01-01")  # Date will be updated per session
                 print(f"🤖 Using MockChatModel (DEV mode)")
             else:
-                self.model = ChatOpenAI(
+                base_model = ChatOpenAI(
                     model=self.basemodel,
                     base_url=self.openai_base_url,
                     api_key=self.openai_api_key,
                     max_retries=3,
                     timeout=30
                 )
-                print(f"🤖 Using {self.basemodel} (PROD mode)")
+                # Wrap model with diagnostic wrapper
+                self.model = ToolCallArgsParsingWrapper(model=base_model)
+                print(f"🤖 Using {self.basemodel} (PROD mode) with diagnostic wrapper")
         except Exception as e:
             raise RuntimeError(f"❌ Failed to initialize AI model: {e}")
 
@@ -319,6 +322,60 @@ class BaseAgent:
             print(f"⚠️ Could not get position from database: {e}")
             return {}, self.initial_cash
 
+    def _calculate_final_position_from_actions(
+        self,
+        trading_day_id: int,
+        starting_cash: float
+    ) -> tuple[Dict[str, int], float]:
+        """
+        Calculate final holdings and cash from starting position + actions.
+
+        This is the correct way to get end-of-day position: start with the
+        starting position and apply all trades from the actions table.
+
+        Args:
+            trading_day_id: The trading day ID
+            starting_cash: Cash at start of day
+
+        Returns:
+            (holdings_dict, final_cash) where holdings_dict maps symbol -> quantity
+        """
+        from api.database import Database
+
+        db = Database()
+
+        # 1. Get starting holdings (from previous day's ending)
+        starting_holdings_list = db.get_starting_holdings(trading_day_id)
+        holdings = {h["symbol"]: h["quantity"] for h in starting_holdings_list}
+
+        # 2. Initialize cash
+        cash = starting_cash
+
+        # 3. Get all actions for this trading day
+        actions = db.get_actions(trading_day_id)
+
+        # 4. Apply each action to calculate final state
+        for action in actions:
+            symbol = action["symbol"]
+            quantity = action["quantity"]
+            price = action["price"]
+            action_type = action["action_type"]
+
+            if action_type == "buy":
+                # Add to holdings
+                holdings[symbol] = holdings.get(symbol, 0) + quantity
+                # Deduct from cash
+                cash -= quantity * price
+
+            elif action_type == "sell":
+                # Remove from holdings
+                holdings[symbol] = holdings.get(symbol, 0) - quantity
+                # Add to cash
+                cash += quantity * price
+
+        # 5. Return final state
+        return holdings, cash
+
     def _calculate_portfolio_value(
         self,
         holdings: Dict[str, int],
@@ -365,7 +422,7 @@ class BaseAgent:
         }
 
         if tool_name:
-            message["tool_name"] = tool_name
+            message["name"] = tool_name  # Use "name" not "tool_name" for consistency with summarizer
         if tool_input:
             message["tool_input"] = tool_input
 
@@ -479,6 +536,8 @@ Summary:"""
         # Update context injector with current trading date
         if self.context_injector:
             self.context_injector.today_date = today_date
+            # Reset position state for new trading day (enables intra-day tracking)
+            self.context_injector.reset_position()
 
         # Clear conversation history for new trading day
         self.clear_conversation_history()
@@ -579,21 +638,28 @@ Summary:"""
                 # Capture assistant response
                 self._capture_message("assistant", agent_response)
 
-                # Check stop signal
-                if STOP_SIGNAL in agent_response:
-                    print("✅ Received stop signal, trading session ended")
-                    print(agent_response)
-                    break
-
-                # Extract tool messages and count trade actions
+                # Extract tool messages BEFORE checking stop signal
+                # (agent may call tools AND return FINISH_SIGNAL in same response)
                 tool_msgs = extract_tool_messages(response)
+                print(f"[DEBUG] Extracted {len(tool_msgs)} tool messages from response")
                 for tool_msg in tool_msgs:
                     tool_name = getattr(tool_msg, 'name', None) or tool_msg.get('name') if isinstance(tool_msg, dict) else None
+                    tool_content = getattr(tool_msg, 'content', '') or tool_msg.get('content', '') if isinstance(tool_msg, dict) else str(tool_msg)
+
+                    # Capture tool message to conversation history
+                    self._capture_message("tool", tool_content, tool_name=tool_name)
+
                     if tool_name in ['buy', 'sell']:
                         action_count += 1
 
                 tool_response = '\n'.join([msg.content for msg in tool_msgs])
 
+                # Check stop signal AFTER processing tools
+                if STOP_SIGNAL in agent_response:
+                    print("✅ Received stop signal, trading session ended")
+                    print(agent_response)
+                    break
+
                 # Prepare new messages
                 new_messages = [
                     {"role": "assistant", "content": agent_response},
@@ -611,11 +677,26 @@ Summary:"""
         session_duration = time.time() - session_start
 
         # 7. Generate reasoning summary
+        # Debug: Log conversation history size
+        print(f"\n[DEBUG] Generating summary from {len(self.conversation_history)} messages")
+        assistant_msgs = [m for m in self.conversation_history if m.get('role') == 'assistant']
+        tool_msgs = [m for m in self.conversation_history if m.get('role') == 'tool']
+        print(f"[DEBUG] Assistant messages: {len(assistant_msgs)}, Tool messages: {len(tool_msgs)}")
+        if assistant_msgs:
+            first_assistant = assistant_msgs[0]
+            print(f"[DEBUG] First assistant message preview: {first_assistant.get('content', '')[:200]}...")
+
         summarizer = ReasoningSummarizer(model=self.model)
         summary = await summarizer.generate_summary(self.conversation_history)
 
-        # 8. Get current portfolio state from database
-        current_holdings, current_cash = self._get_current_portfolio_state(today_date, job_id)
+        # 8. Calculate final portfolio state from starting position + actions
+        # NOTE: We must calculate from actions, not query database, because:
+        # - On first day, database query returns empty (no previous day)
+        # - This method applies all trades to get accurate final state
+        current_holdings, current_cash = self._calculate_final_position_from_actions(
+            trading_day_id=trading_day_id,
+            starting_cash=starting_cash
+        )
 
         # 9. Save final holdings to database
         for symbol, quantity in current_holdings.items():

agent/chat_model_wrapper.py

@@ -0,0 +1,175 @@
+"""
+Chat model wrapper to fix tool_calls args parsing issues.
+
+DeepSeek and other providers return tool_calls.args as JSON strings, which need
+to be parsed to dicts before AIMessage construction.
+"""
+
+import json
+from typing import Any, Optional, Dict
+from functools import wraps
+
+
+class ToolCallArgsParsingWrapper:
+    """
+    Wrapper that adds diagnostic logging and fixes tool_calls args if needed.
+    """
+
+    def __init__(self, model: Any, **kwargs):
+        """
+        Initialize wrapper around a chat model.
+
+        Args:
+            model: The chat model to wrap
+            **kwargs: Additional parameters (ignored, for compatibility)
+        """
+        self.wrapped_model = model
+        self._patch_model()
+
+    def _patch_model(self):
+        """Monkey-patch the model's _create_chat_result to add diagnostics"""
+        if not hasattr(self.wrapped_model, '_create_chat_result'):
+            # Model doesn't have this method (e.g., MockChatModel), skip patching
+            return
+
+        # CRITICAL: Patch parse_tool_call in base.py's namespace (not in openai_tools module!)
+        from langchain_openai.chat_models import base as langchain_base
+        original_parse_tool_call = langchain_base.parse_tool_call
+
+        def patched_parse_tool_call(raw_tool_call, *, partial=False, strict=False, return_id=True):
+            """Patched parse_tool_call to log what it returns"""
+            result = original_parse_tool_call(raw_tool_call, partial=partial, strict=strict, return_id=return_id)
+            if result:
+                args_type = type(result.get('args', None)).__name__
+                print(f"[DIAGNOSTIC] parse_tool_call returned: args type = {args_type}")
+                if args_type == 'str':
+                    print(f"[DIAGNOSTIC] ⚠️ BUG FOUND! parse_tool_call returned STRING args: {result['args']}")
+            return result
+
+        # Replace in base.py's namespace (where _convert_dict_to_message uses it)
+        langchain_base.parse_tool_call = patched_parse_tool_call
+
+        original_create_chat_result = self.wrapped_model._create_chat_result
+
+        @wraps(original_create_chat_result)
+        def patched_create_chat_result(response: Any, generation_info: Optional[Dict] = None):
+            """Patched version with diagnostic logging and args parsing"""
+            import traceback
+            response_dict = response if isinstance(response, dict) else response.model_dump()
+
+            # DIAGNOSTIC: Log response structure for debugging
+            print(f"\n[DIAGNOSTIC] _create_chat_result called")
+            print(f"  Response type: {type(response)}")
+            print(f"  Call stack:")
+            for line in traceback.format_stack()[-5:-1]:  # Show last 4 stack frames
+                print(f"    {line.strip()}")
+            print(f"\n[DIAGNOSTIC] Response structure:")
+            print(f"  Response keys: {list(response_dict.keys())}")
+
+            if 'choices' in response_dict and response_dict['choices']:
+                choice = response_dict['choices'][0]
+                print(f"  Choice keys: {list(choice.keys())}")
+
+                if 'message' in choice:
+                    message = choice['message']
+                    print(f"  Message keys: {list(message.keys())}")
+
+                    # Check for raw tool_calls in message (before parse_tool_call processing)
+                    if 'tool_calls' in message:
+                        tool_calls_value = message['tool_calls']
+                        print(f"  message['tool_calls'] type: {type(tool_calls_value)}")
+
+                        if tool_calls_value:
+                            print(f"  tool_calls count: {len(tool_calls_value)}")
+                            for i, tc in enumerate(tool_calls_value):  # Show ALL
+                                print(f"  tool_calls[{i}] type: {type(tc)}")
+                                print(f"  tool_calls[{i}] keys: {list(tc.keys()) if isinstance(tc, dict) else 'N/A'}")
+                                if isinstance(tc, dict):
+                                    if 'function' in tc:
+                                        print(f"    function keys: {list(tc['function'].keys())}")
+                                        if 'arguments' in tc['function']:
+                                            args = tc['function']['arguments']
+                                            print(f"    function.arguments type: {type(args).__name__}")
+                                            print(f"    function.arguments value: {str(args)[:100]}")
+                                    if 'args' in tc:
+                                        print(f"    ALSO HAS 'args' KEY: type={type(tc['args']).__name__}")
+                                        print(f"    args value: {str(tc['args'])[:100]}")
+
+            # Fix tool_calls: Normalize to OpenAI format if needed
+            if 'choices' in response_dict:
+                for choice in response_dict['choices']:
+                    if 'message' not in choice:
+                        continue
+
+                    message = choice['message']
+
+                    # Fix tool_calls: Ensure standard OpenAI format
+                    if 'tool_calls' in message and message['tool_calls']:
+                        print(f"[DIAGNOSTIC] Processing {len(message['tool_calls'])} tool_calls...")
+                        for idx, tool_call in enumerate(message['tool_calls']):
+                            # Check if this is non-standard format (has 'args' directly)
+                            if 'args' in tool_call and 'function' not in tool_call:
+                                print(f"[DIAGNOSTIC] tool_calls[{idx}] has non-standard format (direct args)")
+                                # Convert to standard OpenAI format
+                                args = tool_call['args']
+                                tool_call['function'] = {
+                                    'name': tool_call.get('name', ''),
+                                    'arguments': args if isinstance(args, str) else json.dumps(args)
+                                }
+                                # Remove non-standard fields
+                                if 'name' in tool_call:
+                                    del tool_call['name']
+                                if 'args' in tool_call:
+                                    del tool_call['args']
+                                print(f"[DIAGNOSTIC] Converted tool_calls[{idx}] to standard OpenAI format")
+
+                    # Fix invalid_tool_calls: dict args -> string
+                    if 'invalid_tool_calls' in message and message['invalid_tool_calls']:
+                        print(f"[DIAGNOSTIC] Checking invalid_tool_calls for dict-to-string conversion...")
+                        for idx, invalid_call in enumerate(message['invalid_tool_calls']):
+                            if 'args' in invalid_call:
+                                args = invalid_call['args']
+                                # Convert dict arguments to JSON string
+                                if isinstance(args, dict):
+                                    try:
+                                        invalid_call['args'] = json.dumps(args)
+                                        print(f"[DIAGNOSTIC] Converted invalid_tool_calls[{idx}].args from dict to string")
+                                    except (TypeError, ValueError) as e:
+                                        print(f"[DIAGNOSTIC] Failed to serialize invalid_tool_calls[{idx}].args: {e}")
+                                        # Keep as-is if serialization fails
+
+            # Call original method with fixed response
+            print(f"[DIAGNOSTIC] Calling original_create_chat_result...")
+            result = original_create_chat_result(response_dict, generation_info)
+            print(f"[DIAGNOSTIC] original_create_chat_result returned successfully")
+            print(f"[DIAGNOSTIC] Result type: {type(result)}")
+            if hasattr(result, 'generations') and result.generations:
+                gen = result.generations[0]
+                if hasattr(gen, 'message') and hasattr(gen.message, 'tool_calls'):
+                    print(f"[DIAGNOSTIC] Result has {len(gen.message.tool_calls)} tool_calls")
+                    if gen.message.tool_calls:
+                        tc = gen.message.tool_calls[0]
+                        print(f"[DIAGNOSTIC] tool_calls[0]['args'] type in result: {type(tc['args'])}")
+            return result
+
+        # Replace the method
+        self.wrapped_model._create_chat_result = patched_create_chat_result
+
+    @property
+    def _llm_type(self) -> str:
+        """Return identifier for this LLM type"""
+        if hasattr(self.wrapped_model, '_llm_type'):
+            return f"wrapped-{self.wrapped_model._llm_type}"
+        return "wrapped-chat-model"
+
+    def __getattr__(self, name: str):
+        """Proxy all attributes/methods to the wrapped model"""
+        return getattr(self.wrapped_model, name)
+
+    def bind_tools(self, tools: Any, **kwargs):
+        """Bind tools to the wrapped model"""
+        return self.wrapped_model.bind_tools(tools, **kwargs)
+
+    def bind(self, **kwargs):
+        """Bind settings to the wrapped model"""
+        return self.wrapped_model.bind(**kwargs)

agent/context_injector.py

@@ -3,15 +3,22 @@ Tool interceptor for injecting runtime context into MCP tool calls.
 
 This interceptor automatically injects `signature` and `today_date` parameters
 into buy/sell tool calls to support concurrent multi-model simulations.
+
+It also maintains in-memory position state to track cumulative changes within
+a single trading session, ensuring sell proceeds are immediately available for
+subsequent buy orders.
 """
 
-from typing import Any, Callable, Awaitable
+from typing import Any, Callable, Awaitable, Dict, Optional
 
 
 class ContextInjector:
     """
     Intercepts tool calls to inject runtime context (signature, today_date).
 
+    Also maintains cumulative position state during trading session to ensure
+    sell proceeds are immediately available for subsequent buys.
+
     Usage:
         interceptor = ContextInjector(signature="gpt-5", today_date="2025-10-01")
         client = MultiServerMCPClient(config, tool_interceptors=[interceptor])
@@ -34,6 +41,13 @@ class ContextInjector:
         self.job_id = job_id
         self.session_id = session_id  # Deprecated but kept for compatibility
         self.trading_day_id = trading_day_id
+        self._current_position: Optional[Dict[str, float]] = None
+
+    def reset_position(self) -> None:
+        """
+        Reset position state (call at start of each trading day).
+        """
+        self._current_position = None
 
     async def __call__(
         self,
@@ -43,6 +57,9 @@ class ContextInjector:
         """
         Intercept tool call and inject context parameters.
 
+        For buy/sell operations, maintains cumulative position state to ensure
+        sell proceeds are immediately available for subsequent buys.
+
         Args:
             request: Tool call request containing name and arguments
             handler: Async callable to execute the actual tool
@@ -52,10 +69,6 @@ class ContextInjector:
         """
         # Inject context parameters for trade tools
         if request.name in ["buy", "sell"]:
-            # Debug: Log self attributes BEFORE injection
-            print(f"[ContextInjector.__call__] ENTRY: id={id(self)}, self.signature={self.signature}, self.today_date={self.today_date}, self.job_id={self.job_id}, self.session_id={self.session_id}, self.trading_day_id={self.trading_day_id}")
-            print(f"[ContextInjector.__call__] Args BEFORE injection: {request.args}")
-
             # ALWAYS inject/override context parameters (don't trust AI-provided values)
             request.args["signature"] = self.signature
             request.args["today_date"] = self.today_date
@@ -66,8 +79,18 @@ class ContextInjector:
             if self.trading_day_id:
                 request.args["trading_day_id"] = self.trading_day_id
 
-            # Debug logging
-            print(f"[ContextInjector] Tool: {request.name}, Args after injection: {request.args}")
+            # Inject current position if we're tracking it
+            if self._current_position is not None:
+                request.args["_current_position"] = self._current_position
 
         # Call the actual tool handler
-        return await handler(request)
+        result = await handler(request)
+
+        # Update position state after successful trade
+        if request.name in ["buy", "sell"]:
+            # Check if result is a valid position dict (not an error)
+            if isinstance(result, dict) and "error" not in result and "CASH" in result:
+                # Update our tracked position with the new state
+                self._current_position = result.copy()
+
+        return result

agent/reasoning_summarizer.py

@@ -36,15 +36,17 @@ class ReasoningSummarizer:
             summary_prompt = f"""You are reviewing your own trading decisions for the day.
 Summarize your trading strategy and key decisions in 2-3 sentences.
 
+IMPORTANT: Explicitly state what trades you executed (e.g., "sold 2 GOOGL shares" or "bought 10 NVDA shares"). If you made no trades, state that clearly.
+
 Focus on:
-- What you analyzed
-- Why you made the trades you did
+- What specific trades you executed (buy/sell, symbols, quantities)
+- Why you made those trades
 - Your overall strategy for the day
 
 Trading session log:
 {log_text}
 
-Provide a concise summary:"""
+Provide a concise summary that includes the actual trades executed:"""
 
             response = await self.model.ainvoke([
                 {"role": "user", "content": summary_prompt}
@@ -67,21 +69,39 @@ Provide a concise summary:"""
             reasoning_log: List of message dicts
 
         Returns:
-            Formatted text representation
+            Formatted text representation with emphasis on trades
         """
+        # Debug: Log what we're formatting
+        print(f"[DEBUG ReasoningSummarizer] Formatting {len(reasoning_log)} messages")
+        assistant_count = sum(1 for m in reasoning_log if m.get('role') == 'assistant')
+        tool_count = sum(1 for m in reasoning_log if m.get('role') == 'tool')
+        print(f"[DEBUG ReasoningSummarizer] Breakdown: {assistant_count} assistant, {tool_count} tool")
+
         formatted_parts = []
+        trades_executed = []
 
         for msg in reasoning_log:
             role = msg.get("role", "")
             content = msg.get("content", "")
+            tool_name = msg.get("name", "")
 
             if role == "assistant":
                 # AI's thoughts
                 formatted_parts.append(f"AI: {content[:200]}")
             elif role == "tool":
-                # Tool results
-                tool_name = msg.get("name", "tool")
-                formatted_parts.append(f"{tool_name}: {content[:100]}")
+                # Highlight trade tool calls
+                if tool_name in ["buy", "sell"]:
+                    trades_executed.append(f"{tool_name.upper()}: {content[:150]}")
+                    formatted_parts.append(f"TRADE - {tool_name.upper()}: {content[:150]}")
+                else:
+                    # Other tool results (search, price, etc.)
+                    formatted_parts.append(f"{tool_name}: {content[:100]}")
+
+        # Add summary of trades at the top
+        if trades_executed:
+            trade_summary = f"TRADES EXECUTED ({len(trades_executed)}):\n" + "\n".join(trades_executed)
+            formatted_parts.insert(0, trade_summary)
+            formatted_parts.insert(1, "\n--- FULL LOG ---")
 
         return "\n".join(formatted_parts)
 

agent_tools/tool_trade.py

@@ -28,16 +28,17 @@ def get_current_position_from_db(
     initial_cash: float = 10000.0
 ) -> Tuple[Dict[str, float], int]:
     """
-    Get current position from database (new schema).
+    Get starting position for current trading day from database (new schema).
 
-    Queries most recent trading_day record for this job+model up to date.
-    Returns ending holdings and cash from that day.
+    Queries most recent trading_day record BEFORE the given date (previous day's ending).
+    Returns ending holdings and cash from that previous day, which becomes the
+    starting position for the current day.
 
     Args:
         job_id: Job UUID
         model: Model signature
-        date: Current trading date
-        initial_cash: Initial cash if no prior data
+        date: Current trading date (will query for date < this)
+        initial_cash: Initial cash if no prior data (first trading day)
 
     Returns:
         (position_dict, action_count) where:
@@ -49,11 +50,11 @@ def get_current_position_from_db(
     cursor = conn.cursor()
 
     try:
-        # Query most recent trading_day up to date
+        # Query most recent trading_day BEFORE current date (previous day's ending position)
         cursor.execute("""
             SELECT id, ending_cash
             FROM trading_days
-            WHERE job_id = ? AND model = ? AND date <= ?
+            WHERE job_id = ? AND model = ? AND date < ?
             ORDER BY date DESC
             LIMIT 1
         """, (job_id, model, date))
@@ -90,7 +91,8 @@ def get_current_position_from_db(
 
 
 def _buy_impl(symbol: str, amount: int, signature: str = None, today_date: str = None,
-              job_id: str = None, session_id: int = None, trading_day_id: int = None) -> Dict[str, Any]:
+              job_id: str = None, session_id: int = None, trading_day_id: int = None,
+              _current_position: Dict[str, float] = None) -> Dict[str, Any]:
     """
     Internal buy implementation - accepts injected context parameters.
 
@@ -102,9 +104,13 @@ def _buy_impl(symbol: str, amount: int, signature: str = None, today_date: str =
         job_id: Job ID (injected)
         session_id: Session ID (injected, DEPRECATED)
         trading_day_id: Trading day ID (injected)
+        _current_position: Current position state (injected by ContextInjector)
 
     This function is not exposed to the AI model. It receives runtime context
     (signature, today_date, job_id, session_id, trading_day_id) from the ContextInjector.
+
+    The _current_position parameter enables intra-day position tracking, ensuring
+    sell proceeds are immediately available for subsequent buys.
     """
     # Validate required parameters
     if not job_id:
@@ -120,7 +126,13 @@ def _buy_impl(symbol: str, amount: int, signature: str = None, today_date: str =
 
     try:
         # Step 1: Get current position
-        current_position, next_action_id = get_current_position_from_db(job_id, signature, today_date)
+        # Use injected position if available (for intra-day tracking),
+        # otherwise query database for starting position
+        if _current_position is not None:
+            current_position = _current_position
+            next_action_id = 0  # Not used in new schema
+        else:
+            current_position, next_action_id = get_current_position_from_db(job_id, signature, today_date)
 
         # Step 2: Get stock price
         try:
@@ -185,7 +197,8 @@ def _buy_impl(symbol: str, amount: int, signature: str = None, today_date: str =
 
 @mcp.tool()
 def buy(symbol: str, amount: int, signature: str = None, today_date: str = None,
-        job_id: str = None, session_id: int = None, trading_day_id: int = None) -> Dict[str, Any]:
+        job_id: str = None, session_id: int = None, trading_day_id: int = None,
+        _current_position: Dict[str, float] = None) -> Dict[str, Any]:
     """
     Buy stock shares.
 
@@ -198,14 +211,15 @@ def buy(symbol: str, amount: int, signature: str = None, today_date: str = None,
           - Success: {"CASH": remaining_cash, "SYMBOL": shares, ...}
           - Failure: {"error": error_message, ...}
 
-    Note: signature, today_date, job_id, session_id, trading_day_id are
-    automatically injected by the system. Do not provide these parameters.
+    Note: signature, today_date, job_id, session_id, trading_day_id, _current_position
+    are automatically injected by the system. Do not provide these parameters.
     """
-    return _buy_impl(symbol, amount, signature, today_date, job_id, session_id, trading_day_id)
+    return _buy_impl(symbol, amount, signature, today_date, job_id, session_id, trading_day_id, _current_position)
 
 
 def _sell_impl(symbol: str, amount: int, signature: str = None, today_date: str = None,
-               job_id: str = None, session_id: int = None, trading_day_id: int = None) -> Dict[str, Any]:
+               job_id: str = None, session_id: int = None, trading_day_id: int = None,
+               _current_position: Dict[str, float] = None) -> Dict[str, Any]:
     """
     Sell stock function - writes to SQLite database.
 
@@ -217,11 +231,15 @@ def _sell_impl(symbol: str, amount: int, signature: str = None, today_date: str
         job_id: Job UUID (injected by ContextInjector)
         session_id: Trading session ID (injected by ContextInjector, DEPRECATED)
         trading_day_id: Trading day ID (injected by ContextInjector)
+        _current_position: Current position state (injected by ContextInjector)
 
     Returns:
         Dict[str, Any]:
           - Success: {"CASH": amount, symbol: quantity, ...}
           - Failure: {"error": message, ...}
+
+    The _current_position parameter enables intra-day position tracking, ensuring
+    sell proceeds are immediately available for subsequent buys.
     """
     # Validate required parameters
     if not job_id:
@@ -237,7 +255,13 @@ def _sell_impl(symbol: str, amount: int, signature: str = None, today_date: str
 
     try:
         # Step 1: Get current position
-        current_position, next_action_id = get_current_position_from_db(job_id, signature, today_date)
+        # Use injected position if available (for intra-day tracking),
+        # otherwise query database for starting position
+        if _current_position is not None:
+            current_position = _current_position
+            next_action_id = 0  # Not used in new schema
+        else:
+            current_position, next_action_id = get_current_position_from_db(job_id, signature, today_date)
 
         # Step 2: Validate position exists
         if symbol not in current_position:
@@ -297,7 +321,8 @@ def _sell_impl(symbol: str, amount: int, signature: str = None, today_date: str
 
 @mcp.tool()
 def sell(symbol: str, amount: int, signature: str = None, today_date: str = None,
-         job_id: str = None, session_id: int = None, trading_day_id: int = None) -> Dict[str, Any]:
+         job_id: str = None, session_id: int = None, trading_day_id: int = None,
+         _current_position: Dict[str, float] = None) -> Dict[str, Any]:
     """
     Sell stock shares.
 
@@ -310,10 +335,10 @@ def sell(symbol: str, amount: int, signature: str = None, today_date: str = None
           - Success: {"CASH": remaining_cash, "SYMBOL": shares, ...}
           - Failure: {"error": error_message, ...}
 
-    Note: signature, today_date, job_id, session_id, trading_day_id are
-    automatically injected by the system. Do not provide these parameters.
+    Note: signature, today_date, job_id, session_id, trading_day_id, _current_position
+    are automatically injected by the system. Do not provide these parameters.
     """
-    return _sell_impl(symbol, amount, signature, today_date, job_id, session_id, trading_day_id)
+    return _sell_impl(symbol, amount, signature, today_date, job_id, session_id, trading_day_id, _current_position)
 
 
 if __name__ == "__main__":

api/runtime_manager.py

@@ -80,7 +80,7 @@ class RuntimeConfigManager:
         initial_config = {
             "TODAY_DATE": date,
             "SIGNATURE": model_sig,
-            "IF_TRADE": False,
+            "IF_TRADE": True,  # FIX: Trades are expected by default
             "JOB_ID": job_id,
             "TRADING_DAY_ID": trading_day_id
         }

tests/unit/test_calculate_final_position.py

@@ -0,0 +1,219 @@
+"""Test _calculate_final_position_from_actions method."""
+
+import pytest
+from unittest.mock import patch
+from agent.base_agent.base_agent import BaseAgent
+from api.database import Database
+
+
+@pytest.fixture
+def test_db():
+    """Create test database with schema."""
+    db = Database(":memory:")
+
+    # Create jobs record
+    db.connection.execute("""
+        INSERT INTO jobs (job_id, config_path, status, date_range, models, created_at)
+        VALUES ('test-job', 'test.json', 'running', '2025-10-07 to 2025-10-07', 'gpt-5', '2025-10-07T00:00:00Z')
+    """)
+    db.connection.commit()
+
+    return db
+
+
+def test_calculate_final_position_first_day_with_trades(test_db):
+    """Test calculating final position on first trading day with multiple trades."""
+
+    # Create trading_day for first day
+    trading_day_id = test_db.create_trading_day(
+        job_id='test-job',
+        model='gpt-5',
+        date='2025-10-07',
+        starting_cash=10000.0,
+        starting_portfolio_value=10000.0,
+        daily_profit=0.0,
+        daily_return_pct=0.0,
+        ending_cash=10000.0,  # Not yet calculated
+        ending_portfolio_value=10000.0,  # Not yet calculated
+        days_since_last_trading=1
+    )
+
+    # Add 15 buy actions (matching your real data)
+    actions_data = [
+        ("MSFT", 3, 528.285, "buy"),
+        ("GOOGL", 6, 248.27, "buy"),
+        ("NVDA", 10, 186.23, "buy"),
+        ("LRCX", 6, 149.23, "buy"),
+        ("AVGO", 2, 337.025, "buy"),
+        ("AMZN", 5, 220.88, "buy"),
+        ("MSFT", 2, 528.285, "buy"),  # Additional MSFT
+        ("AMD", 4, 214.85, "buy"),
+        ("CRWD", 1, 497.0, "buy"),
+        ("QCOM", 4, 169.9, "buy"),
+        ("META", 1, 717.72, "buy"),
+        ("NVDA", 20, 186.23, "buy"),  # Additional NVDA
+        ("NVDA", 13, 186.23, "buy"),  # Additional NVDA
+        ("NVDA", 20, 186.23, "buy"),  # Additional NVDA
+        ("NVDA", 53, 186.23, "buy"),  # Additional NVDA
+    ]
+
+    for symbol, quantity, price, action_type in actions_data:
+        test_db.create_action(
+            trading_day_id=trading_day_id,
+            action_type=action_type,
+            symbol=symbol,
+            quantity=quantity,
+            price=price
+        )
+
+    test_db.connection.commit()
+
+    # Create BaseAgent instance
+    agent = BaseAgent(signature="gpt-5", basemodel="anthropic/claude-sonnet-4", stock_symbols=[])
+
+    # Mock Database() to return our test_db
+    with patch('api.database.Database', return_value=test_db):
+        # Calculate final position
+        holdings, cash = agent._calculate_final_position_from_actions(
+            trading_day_id=trading_day_id,
+            starting_cash=10000.0
+        )
+
+    # Verify holdings
+    assert holdings["MSFT"] == 5, f"Expected 5 MSFT (3+2) but got {holdings.get('MSFT', 0)}"
+    assert holdings["GOOGL"] == 6, f"Expected 6 GOOGL but got {holdings.get('GOOGL', 0)}"
+    assert holdings["NVDA"] == 116, f"Expected 116 NVDA (10+20+13+20+53) but got {holdings.get('NVDA', 0)}"
+    assert holdings["LRCX"] == 6, f"Expected 6 LRCX but got {holdings.get('LRCX', 0)}"
+    assert holdings["AVGO"] == 2, f"Expected 2 AVGO but got {holdings.get('AVGO', 0)}"
+    assert holdings["AMZN"] == 5, f"Expected 5 AMZN but got {holdings.get('AMZN', 0)}"
+    assert holdings["AMD"] == 4, f"Expected 4 AMD but got {holdings.get('AMD', 0)}"
+    assert holdings["CRWD"] == 1, f"Expected 1 CRWD but got {holdings.get('CRWD', 0)}"
+    assert holdings["QCOM"] == 4, f"Expected 4 QCOM but got {holdings.get('QCOM', 0)}"
+    assert holdings["META"] == 1, f"Expected 1 META but got {holdings.get('META', 0)}"
+
+    # Verify cash (should be less than starting)
+    assert cash < 10000.0, f"Cash should be less than $10,000 but got ${cash}"
+
+    # Calculate expected cash
+    total_spent = sum(qty * price for _, qty, price, _ in actions_data)
+    expected_cash = 10000.0 - total_spent
+    assert abs(cash - expected_cash) < 0.01, f"Expected cash ${expected_cash} but got ${cash}"
+
+
+def test_calculate_final_position_with_previous_holdings(test_db):
+    """Test calculating final position when starting with existing holdings."""
+
+    # Create day 1 with ending holdings
+    day1_id = test_db.create_trading_day(
+        job_id='test-job',
+        model='gpt-5',
+        date='2025-10-06',
+        starting_cash=10000.0,
+        starting_portfolio_value=10000.0,
+        daily_profit=0.0,
+        daily_return_pct=0.0,
+        ending_cash=8000.0,
+        ending_portfolio_value=9500.0,
+        days_since_last_trading=1
+    )
+
+    # Add day 1 ending holdings
+    test_db.create_holding(day1_id, "AAPL", 10)
+    test_db.create_holding(day1_id, "MSFT", 5)
+
+    # Create day 2
+    day2_id = test_db.create_trading_day(
+        job_id='test-job',
+        model='gpt-5',
+        date='2025-10-07',
+        starting_cash=8000.0,
+        starting_portfolio_value=9500.0,
+        daily_profit=0.0,
+        daily_return_pct=0.0,
+        ending_cash=8000.0,
+        ending_portfolio_value=9500.0,
+        days_since_last_trading=1
+    )
+
+    # Add day 2 actions (buy more AAPL, sell some MSFT)
+    test_db.create_action(day2_id, "buy", "AAPL", 5, 150.0)
+    test_db.create_action(day2_id, "sell", "MSFT", 2, 500.0)
+
+    test_db.connection.commit()
+
+    # Create BaseAgent instance
+    agent = BaseAgent(signature="gpt-5", basemodel="anthropic/claude-sonnet-4", stock_symbols=[])
+
+    # Mock Database() to return our test_db
+    with patch('api.database.Database', return_value=test_db):
+        # Calculate final position for day 2
+        holdings, cash = agent._calculate_final_position_from_actions(
+            trading_day_id=day2_id,
+            starting_cash=8000.0
+        )
+
+    # Verify holdings
+    assert holdings["AAPL"] == 15, f"Expected 15 AAPL (10+5) but got {holdings.get('AAPL', 0)}"
+    assert holdings["MSFT"] == 3, f"Expected 3 MSFT (5-2) but got {holdings.get('MSFT', 0)}"
+
+    # Verify cash
+    # Started: 8000
+    # Buy 5 AAPL @ 150 = -750
+    # Sell 2 MSFT @ 500 = +1000
+    # Final: 8000 - 750 + 1000 = 8250
+    expected_cash = 8000.0 - (5 * 150.0) + (2 * 500.0)
+    assert abs(cash - expected_cash) < 0.01, f"Expected cash ${expected_cash} but got ${cash}"
+
+
+def test_calculate_final_position_no_trades(test_db):
+    """Test calculating final position when no trades were executed."""
+
+    # Create day 1 with ending holdings
+    day1_id = test_db.create_trading_day(
+        job_id='test-job',
+        model='gpt-5',
+        date='2025-10-06',
+        starting_cash=10000.0,
+        starting_portfolio_value=10000.0,
+        daily_profit=0.0,
+        daily_return_pct=0.0,
+        ending_cash=9000.0,
+        ending_portfolio_value=10000.0,
+        days_since_last_trading=1
+    )
+
+    test_db.create_holding(day1_id, "AAPL", 10)
+
+    # Create day 2 with NO actions
+    day2_id = test_db.create_trading_day(
+        job_id='test-job',
+        model='gpt-5',
+        date='2025-10-07',
+        starting_cash=9000.0,
+        starting_portfolio_value=10000.0,
+        daily_profit=0.0,
+        daily_return_pct=0.0,
+        ending_cash=9000.0,
+        ending_portfolio_value=10000.0,
+        days_since_last_trading=1
+    )
+
+    # No actions added
+    test_db.connection.commit()
+
+    # Create BaseAgent instance
+    agent = BaseAgent(signature="gpt-5", basemodel="anthropic/claude-sonnet-4", stock_symbols=[])
+
+    # Mock Database() to return our test_db
+    with patch('api.database.Database', return_value=test_db):
+        # Calculate final position
+        holdings, cash = agent._calculate_final_position_from_actions(
+            trading_day_id=day2_id,
+            starting_cash=9000.0
+        )
+
+    # Verify holdings unchanged
+    assert holdings["AAPL"] == 10, f"Expected 10 AAPL but got {holdings.get('AAPL', 0)}"
+
+    # Verify cash unchanged
+    assert abs(cash - 9000.0) < 0.01, f"Expected cash $9000 but got ${cash}"

tests/unit/test_chat_model_wrapper.py

@@ -0,0 +1,216 @@
+"""
+Unit tests for ChatModelWrapper - tool_calls args parsing fix
+"""
+
+import json
+import pytest
+from unittest.mock import Mock, AsyncMock
+from langchain_core.messages import AIMessage
+from langchain_core.outputs import ChatResult, ChatGeneration
+
+from agent.chat_model_wrapper import ToolCallArgsParsingWrapper
+
+
+class TestToolCallArgsParsingWrapper:
+    """Tests for ToolCallArgsParsingWrapper"""
+
+    @pytest.fixture
+    def mock_model(self):
+        """Create a mock chat model"""
+        model = Mock()
+        model._llm_type = "mock-model"
+        return model
+
+    @pytest.fixture
+    def wrapper(self, mock_model):
+        """Create a wrapper around mock model"""
+        return ToolCallArgsParsingWrapper(model=mock_model)
+
+    def test_fix_tool_calls_with_string_args(self, wrapper):
+        """Test that string args are parsed to dict"""
+        # Create message with tool_calls where args is a JSON string
+        message = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "buy",
+                    "args": '{"symbol": "AAPL", "amount": 10}',  # String, not dict
+                    "id": "call_123"
+                }
+            ]
+        )
+
+        fixed_message = wrapper._fix_tool_calls(message)
+
+        # Check that args is now a dict
+        assert isinstance(fixed_message.tool_calls[0]['args'], dict)
+        assert fixed_message.tool_calls[0]['args'] == {"symbol": "AAPL", "amount": 10}
+
+    def test_fix_tool_calls_with_dict_args(self, wrapper):
+        """Test that dict args are left unchanged"""
+        # Create message with tool_calls where args is already a dict
+        message = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "buy",
+                    "args": {"symbol": "AAPL", "amount": 10},  # Already a dict
+                    "id": "call_123"
+                }
+            ]
+        )
+
+        fixed_message = wrapper._fix_tool_calls(message)
+
+        # Check that args is still a dict
+        assert isinstance(fixed_message.tool_calls[0]['args'], dict)
+        assert fixed_message.tool_calls[0]['args'] == {"symbol": "AAPL", "amount": 10}
+
+    def test_fix_tool_calls_with_invalid_json(self, wrapper):
+        """Test that invalid JSON string is left unchanged"""
+        # Create message with tool_calls where args is an invalid JSON string
+        message = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "buy",
+                    "args": 'invalid json {',  # Invalid JSON
+                    "id": "call_123"
+                }
+            ]
+        )
+
+        fixed_message = wrapper._fix_tool_calls(message)
+
+        # Check that args is still a string (parsing failed)
+        assert isinstance(fixed_message.tool_calls[0]['args'], str)
+        assert fixed_message.tool_calls[0]['args'] == 'invalid json {'
+
+    def test_fix_tool_calls_no_tool_calls(self, wrapper):
+        """Test that messages without tool_calls are left unchanged"""
+        message = AIMessage(content="Hello, world!")
+        fixed_message = wrapper._fix_tool_calls(message)
+
+        assert fixed_message == message
+
+    def test_generate_with_string_args(self, wrapper, mock_model):
+        """Test _generate method with string args"""
+        # Create a response with string args
+        original_message = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "buy",
+                    "args": '{"symbol": "MSFT", "amount": 5}',
+                    "id": "call_456"
+                }
+            ]
+        )
+
+        mock_result = ChatResult(
+            generations=[ChatGeneration(message=original_message)]
+        )
+        mock_model._generate.return_value = mock_result
+
+        # Call wrapper's _generate
+        result = wrapper._generate(messages=[], stop=None, run_manager=None)
+
+        # Check that args is now a dict
+        fixed_message = result.generations[0].message
+        assert isinstance(fixed_message.tool_calls[0]['args'], dict)
+        assert fixed_message.tool_calls[0]['args'] == {"symbol": "MSFT", "amount": 5}
+
+    @pytest.mark.asyncio
+    async def test_agenerate_with_string_args(self, wrapper, mock_model):
+        """Test _agenerate method with string args"""
+        # Create a response with string args
+        original_message = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "sell",
+                    "args": '{"symbol": "GOOGL", "amount": 3}',
+                    "id": "call_789"
+                }
+            ]
+        )
+
+        mock_result = ChatResult(
+            generations=[ChatGeneration(message=original_message)]
+        )
+        mock_model._agenerate = AsyncMock(return_value=mock_result)
+
+        # Call wrapper's _agenerate
+        result = await wrapper._agenerate(messages=[], stop=None, run_manager=None)
+
+        # Check that args is now a dict
+        fixed_message = result.generations[0].message
+        assert isinstance(fixed_message.tool_calls[0]['args'], dict)
+        assert fixed_message.tool_calls[0]['args'] == {"symbol": "GOOGL", "amount": 3}
+
+    def test_invoke_with_string_args(self, wrapper, mock_model):
+        """Test invoke method with string args"""
+        original_message = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "buy",
+                    "args": '{"symbol": "NVDA", "amount": 20}',
+                    "id": "call_999"
+                }
+            ]
+        )
+
+        mock_model.invoke.return_value = original_message
+
+        # Call wrapper's invoke
+        result = wrapper.invoke(input=[])
+
+        # Check that args is now a dict
+        assert isinstance(result.tool_calls[0]['args'], dict)
+        assert result.tool_calls[0]['args'] == {"symbol": "NVDA", "amount": 20}
+
+    @pytest.mark.asyncio
+    async def test_ainvoke_with_string_args(self, wrapper, mock_model):
+        """Test ainvoke method with string args"""
+        original_message = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "sell",
+                    "args": '{"symbol": "TSLA", "amount": 15}',
+                    "id": "call_111"
+                }
+            ]
+        )
+
+        mock_model.ainvoke = AsyncMock(return_value=original_message)
+
+        # Call wrapper's ainvoke
+        result = await wrapper.ainvoke(input=[])
+
+        # Check that args is now a dict
+        assert isinstance(result.tool_calls[0]['args'], dict)
+        assert result.tool_calls[0]['args'] == {"symbol": "TSLA", "amount": 15}
+
+    def test_bind_tools_returns_wrapper(self, wrapper, mock_model):
+        """Test that bind_tools returns a new wrapper"""
+        mock_bound = Mock()
+        mock_model.bind_tools.return_value = mock_bound
+
+        result = wrapper.bind_tools(tools=[], strict=True)
+
+        # Check that result is a wrapper around the bound model
+        assert isinstance(result, ToolCallArgsParsingWrapper)
+        assert result.wrapped_model == mock_bound
+
+    def test_bind_returns_wrapper(self, wrapper, mock_model):
+        """Test that bind returns a new wrapper"""
+        mock_bound = Mock()
+        mock_model.bind.return_value = mock_bound
+
+        result = wrapper.bind(max_tokens=100)
+
+        # Check that result is a wrapper around the bound model
+        assert isinstance(result, ToolCallArgsParsingWrapper)
+        assert result.wrapped_model == mock_bound

tests/unit/test_context_injector.py

@@ -0,0 +1,192 @@
+"""Test ContextInjector position tracking functionality."""
+
+import pytest
+from agent.context_injector import ContextInjector
+
+
+@pytest.fixture
+def injector():
+    """Create a ContextInjector instance for testing."""
+    return ContextInjector(
+        signature="test-model",
+        today_date="2025-01-15",
+        job_id="test-job-123",
+        trading_day_id=1
+    )
+
+
+class MockRequest:
+    """Mock MCP tool request."""
+    def __init__(self, name, args=None):
+        self.name = name
+        self.args = args or {}
+
+
+async def mock_handler_success(request):
+    """Mock handler that returns a successful position update."""
+    # Simulate a successful trade returning updated position
+    if request.name == "sell":
+        return {
+            "CASH": 1100.0,
+            "AAPL": 7,
+            "MSFT": 5
+        }
+    elif request.name == "buy":
+        return {
+            "CASH": 50.0,
+            "AAPL": 7,
+            "MSFT": 12
+        }
+    return {}
+
+
+async def mock_handler_error(request):
+    """Mock handler that returns an error."""
+    return {"error": "Insufficient cash"}
+
+
+@pytest.mark.asyncio
+async def test_context_injector_initializes_with_no_position(injector):
+    """Test that ContextInjector starts with no position state."""
+    assert injector._current_position is None
+
+
+@pytest.mark.asyncio
+async def test_context_injector_reset_position(injector):
+    """Test that reset_position() clears position state."""
+    # Set some position state
+    injector._current_position = {"CASH": 5000.0, "AAPL": 10}
+
+    # Reset
+    injector.reset_position()
+
+    assert injector._current_position is None
+
+
+@pytest.mark.asyncio
+async def test_context_injector_injects_parameters(injector):
+    """Test that context parameters are injected into buy/sell requests."""
+    request = MockRequest("buy", {"symbol": "AAPL", "amount": 10})
+
+    # Mock handler that just returns the request args
+    async def handler(req):
+        return req.args
+
+    result = await injector(request, handler)
+
+    # Verify context was injected
+    assert result["signature"] == "test-model"
+    assert result["today_date"] == "2025-01-15"
+    assert result["job_id"] == "test-job-123"
+    assert result["trading_day_id"] == 1
+
+
+@pytest.mark.asyncio
+async def test_context_injector_tracks_position_after_successful_trade(injector):
+    """Test that position state is updated after successful trades."""
+    assert injector._current_position is None
+
+    # Execute a sell trade
+    request = MockRequest("sell", {"symbol": "AAPL", "amount": 3})
+    result = await injector(request, mock_handler_success)
+
+    # Verify position was updated
+    assert injector._current_position is not None
+    assert injector._current_position["CASH"] == 1100.0
+    assert injector._current_position["AAPL"] == 7
+    assert injector._current_position["MSFT"] == 5
+
+
+@pytest.mark.asyncio
+async def test_context_injector_injects_current_position_on_subsequent_trades(injector):
+    """Test that current position is injected into subsequent trade requests."""
+    # First trade - establish position
+    request1 = MockRequest("sell", {"symbol": "AAPL", "amount": 3})
+    await injector(request1, mock_handler_success)
+
+    # Second trade - should receive current position
+    request2 = MockRequest("buy", {"symbol": "MSFT", "amount": 7})
+
+    async def verify_injection_handler(req):
+        # Verify that _current_position was injected
+        assert "_current_position" in req.args
+        assert req.args["_current_position"]["CASH"] == 1100.0
+        assert req.args["_current_position"]["AAPL"] == 7
+        return mock_handler_success(req)
+
+    await injector(request2, verify_injection_handler)
+
+
+@pytest.mark.asyncio
+async def test_context_injector_does_not_update_position_on_error(injector):
+    """Test that position state is NOT updated when trade fails."""
+    # First successful trade
+    request1 = MockRequest("sell", {"symbol": "AAPL", "amount": 3})
+    await injector(request1, mock_handler_success)
+
+    original_position = injector._current_position.copy()
+
+    # Second trade that fails
+    request2 = MockRequest("buy", {"symbol": "MSFT", "amount": 100})
+    result = await injector(request2, mock_handler_error)
+
+    # Verify position was NOT updated
+    assert injector._current_position == original_position
+    assert "error" in result
+
+
+@pytest.mark.asyncio
+async def test_context_injector_does_not_inject_position_for_non_trade_tools(injector):
+    """Test that position is not injected for non-buy/sell tools."""
+    # Set up position state
+    injector._current_position = {"CASH": 5000.0, "AAPL": 10}
+
+    # Call a non-trade tool
+    request = MockRequest("search", {"query": "market news"})
+
+    async def verify_no_injection_handler(req):
+        assert "_current_position" not in req.args
+        return {"results": []}
+
+    await injector(request, verify_no_injection_handler)
+
+
+@pytest.mark.asyncio
+async def test_context_injector_full_trading_session_simulation(injector):
+    """Test full trading session with multiple trades and position tracking."""
+    # Reset position at start of day
+    injector.reset_position()
+    assert injector._current_position is None
+
+    # Trade 1: Sell AAPL
+    request1 = MockRequest("sell", {"symbol": "AAPL", "amount": 3})
+
+    async def handler1(req):
+        # First trade should NOT have injected position
+        assert req.args.get("_current_position") is None
+        return {"CASH": 1100.0, "AAPL": 7}
+
+    result1 = await injector(request1, handler1)
+    assert injector._current_position == {"CASH": 1100.0, "AAPL": 7}
+
+    # Trade 2: Buy MSFT (should use position from trade 1)
+    request2 = MockRequest("buy", {"symbol": "MSFT", "amount": 7})
+
+    async def handler2(req):
+        # Second trade SHOULD have injected position from trade 1
+        assert req.args["_current_position"]["CASH"] == 1100.0
+        assert req.args["_current_position"]["AAPL"] == 7
+        return {"CASH": 50.0, "AAPL": 7, "MSFT": 7}
+
+    result2 = await injector(request2, handler2)
+    assert injector._current_position == {"CASH": 50.0, "AAPL": 7, "MSFT": 7}
+
+    # Trade 3: Failed trade (should not update position)
+    request3 = MockRequest("buy", {"symbol": "GOOGL", "amount": 100})
+
+    async def handler3(req):
+        return {"error": "Insufficient cash", "cash_available": 50.0}
+
+    result3 = await injector(request3, handler3)
+    # Position should remain unchanged after failed trade
+    assert injector._current_position == {"CASH": 50.0, "AAPL": 7, "MSFT": 7}

tests/unit/test_get_position_new_schema.py

@@ -6,7 +6,7 @@ from api.database import Database
 
 
 def test_get_position_from_new_schema():
-    """Test position retrieval from trading_days + holdings."""
+    """Test position retrieval from trading_days + holdings (previous day)."""
 
     # Create test database
     db = Database(":memory:")
@@ -14,11 +14,11 @@ def test_get_position_from_new_schema():
     # Create prerequisite: jobs record
     db.connection.execute("""
         INSERT INTO jobs (job_id, config_path, status, date_range, models, created_at)
-        VALUES ('test-job-123', 'test_config.json', 'running', '2025-01-15 to 2025-01-15', 'test-model', '2025-01-15T10:00:00Z')
+        VALUES ('test-job-123', 'test_config.json', 'running', '2025-01-14 to 2025-01-16', 'test-model', '2025-01-14T10:00:00Z')
     """)
     db.connection.commit()
 
-    # Create trading_day with holdings
+    # Create trading_day with holdings for 2025-01-15
     trading_day_id = db.create_trading_day(
         job_id='test-job-123',
         model='test-model',
@@ -32,7 +32,7 @@ def test_get_position_from_new_schema():
         days_since_last_trading=0
     )
 
-    # Add ending holdings
+    # Add ending holdings for 2025-01-15
     db.create_holding(trading_day_id, 'AAPL', 10)
     db.create_holding(trading_day_id, 'MSFT', 5)
 
@@ -48,18 +48,19 @@ def test_get_position_from_new_schema():
     trade_module.get_db_connection = mock_get_db_connection
 
     try:
-        # Query position
+        # Query position for NEXT day (2025-01-16)
+        # Should retrieve previous day's (2025-01-15) ending position
         position, action_id = get_current_position_from_db(
             job_id='test-job-123',
             model='test-model',
-            date='2025-01-15'
+            date='2025-01-16'  # Query for day AFTER the trading_day record
         )
 
-        # Verify
-        assert position['AAPL'] == 10
-        assert position['MSFT'] == 5
-        assert position['CASH'] == 8000.0
-        assert action_id == 2  # 2 holdings = 2 actions
+        # Verify we got the previous day's ending position
+        assert position['AAPL'] == 10, f"Expected 10 AAPL but got {position.get('AAPL', 0)}"
+        assert position['MSFT'] == 5, f"Expected 5 MSFT but got {position.get('MSFT', 0)}"
+        assert position['CASH'] == 8000.0, f"Expected cash $8000 but got ${position['CASH']}"
+        assert action_id == 2, f"Expected 2 holdings but got {action_id}"
     finally:
         # Restore original function
         trade_module.get_db_connection = original_get_db_connection
@@ -95,3 +96,99 @@ def test_get_position_first_day():
         # Restore original function
         trade_module.get_db_connection = original_get_db_connection
         db.connection.close()
+
+
+def test_get_position_retrieves_previous_day_not_current():
+    """Test that get_current_position_from_db queries PREVIOUS day's ending, not current day.
+
+    This is the critical fix: when querying for day 2's starting position,
+    it should return day 1's ending position, NOT day 2's (incomplete) position.
+    """
+
+    db = Database(":memory:")
+
+    # Create prerequisite: jobs record
+    db.connection.execute("""
+        INSERT INTO jobs (job_id, config_path, status, date_range, models, created_at)
+        VALUES ('test-job-123', 'test_config.json', 'running', '2025-10-01 to 2025-10-03', 'gpt-5', '2025-10-01T10:00:00Z')
+    """)
+    db.connection.commit()
+
+    # Day 1: Create complete trading day with holdings
+    day1_id = db.create_trading_day(
+        job_id='test-job-123',
+        model='gpt-5',
+        date='2025-10-02',
+        starting_cash=10000.0,
+        starting_portfolio_value=10000.0,
+        daily_profit=0.0,
+        daily_return_pct=0.0,
+        ending_cash=2500.0,  # After buying stocks
+        ending_portfolio_value=10000.0,
+        days_since_last_trading=1
+    )
+
+    # Day 1 ending holdings (7 AMZN, 5 GOOGL, 6 MU, 3 QCOM, 4 MSFT, 1 CRWD, 10 NVDA, 3 AVGO)
+    db.create_holding(day1_id, 'AMZN', 7)
+    db.create_holding(day1_id, 'GOOGL', 5)
+    db.create_holding(day1_id, 'MU', 6)
+    db.create_holding(day1_id, 'QCOM', 3)
+    db.create_holding(day1_id, 'MSFT', 4)
+    db.create_holding(day1_id, 'CRWD', 1)
+    db.create_holding(day1_id, 'NVDA', 10)
+    db.create_holding(day1_id, 'AVGO', 3)
+
+    # Day 2: Create incomplete trading day (just started, no holdings yet)
+    day2_id = db.create_trading_day(
+        job_id='test-job-123',
+        model='gpt-5',
+        date='2025-10-03',
+        starting_cash=2500.0,  # From day 1 ending
+        starting_portfolio_value=10000.0,
+        daily_profit=0.0,
+        daily_return_pct=0.0,
+        ending_cash=2500.0,  # Not finalized yet
+        ending_portfolio_value=10000.0,  # Not finalized yet
+        days_since_last_trading=1
+    )
+    # NOTE: No holdings created for day 2 yet (trading in progress)
+
+    db.connection.commit()
+
+    # Mock get_db_connection to return our test db
+    import agent_tools.tool_trade as trade_module
+    original_get_db_connection = trade_module.get_db_connection
+
+    def mock_get_db_connection(path):
+        return db.connection
+
+    trade_module.get_db_connection = mock_get_db_connection
+
+    try:
+        # Query starting position for day 2 (2025-10-03)
+        # This should return day 1's ending position, NOT day 2's incomplete position
+        position, action_id = get_current_position_from_db(
+            job_id='test-job-123',
+            model='gpt-5',
+            date='2025-10-03'
+        )
+
+        # Verify we got day 1's ending position (8 holdings)
+        assert position['CASH'] == 2500.0, f"Expected cash $2500 but got ${position['CASH']}"
+        assert position['AMZN'] == 7, f"Expected 7 AMZN but got {position.get('AMZN', 0)}"
+        assert position['GOOGL'] == 5, f"Expected 5 GOOGL but got {position.get('GOOGL', 0)}"
+        assert position['MU'] == 6, f"Expected 6 MU but got {position.get('MU', 0)}"
+        assert position['QCOM'] == 3, f"Expected 3 QCOM but got {position.get('QCOM', 0)}"
+        assert position['MSFT'] == 4, f"Expected 4 MSFT but got {position.get('MSFT', 0)}"
+        assert position['CRWD'] == 1, f"Expected 1 CRWD but got {position.get('CRWD', 0)}"
+        assert position['NVDA'] == 10, f"Expected 10 NVDA but got {position.get('NVDA', 0)}"
+        assert position['AVGO'] == 3, f"Expected 3 AVGO but got {position.get('AVGO', 0)}"
+        assert action_id == 8, f"Expected 8 holdings but got {action_id}"
+
+        # Verify total holdings count (should NOT include day 2's empty holdings)
+        assert len(position) == 9, f"Expected 9 items (8 stocks + CASH) but got {len(position)}"
+
+    finally:
+        # Restore original function
+        trade_module.get_db_connection = original_get_db_connection
+        db.connection.close()

tests/unit/test_runtime_manager.py

@@ -63,7 +63,7 @@ class TestRuntimeConfigCreation:
 
             assert config["TODAY_DATE"] == "2025-01-16"
             assert config["SIGNATURE"] == "gpt-5"
-            assert config["IF_TRADE"] is False
+            assert config["IF_TRADE"] is True
             assert config["JOB_ID"] == "test-job-123"
 
     def test_create_runtime_config_unique_paths(self):
@@ -108,6 +108,32 @@ class TestRuntimeConfigCreation:
             # Config file should exist
             assert os.path.exists(config_path)
 
+    def test_create_runtime_config_if_trade_defaults_true(self):
+        """Test that IF_TRADE initializes to True (trades expected by default)"""
+        from api.runtime_manager import RuntimeConfigManager
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            manager = RuntimeConfigManager(data_dir=temp_dir)
+
+            config_path = manager.create_runtime_config(
+                job_id="test-job-123",
+                model_sig="test-model",
+                date="2025-01-16",
+                trading_day_id=1
+            )
+
+            try:
+                # Read the config file
+                with open(config_path, 'r') as f:
+                    config = json.load(f)
+
+                # Verify IF_TRADE is True by default
+                assert config["IF_TRADE"] is True, "IF_TRADE should initialize to True"
+            finally:
+                # Cleanup
+                if os.path.exists(config_path):
+                    os.remove(config_path)
+
 
 @pytest.mark.unit
 class TestRuntimeConfigCleanup:

tests/unit/test_trade_tools_new_schema.py

@@ -295,3 +295,190 @@ def test_sell_writes_to_actions_table(test_db, monkeypatch):
     assert row[1] == 'AAPL'
     assert row[2] == 5
     assert row[3] == 160.0
+
+
+def test_intraday_position_tracking_sell_then_buy(test_db, monkeypatch):
+    """Test that sell proceeds are immediately available for subsequent buys."""
+    db, trading_day_id = test_db
+
+    # Setup: Create starting position with AAPL shares and limited cash
+    db.create_holding(trading_day_id, 'AAPL', 10)
+    db.connection.commit()
+
+    # Create a mock connection wrapper
+    class MockConnection:
+        def __init__(self, real_conn):
+            self.real_conn = real_conn
+
+        def cursor(self):
+            return self.real_conn.cursor()
+
+        def commit(self):
+            return self.real_conn.commit()
+
+        def rollback(self):
+            return self.real_conn.rollback()
+
+        def close(self):
+            pass
+
+    mock_conn = MockConnection(db.connection)
+    monkeypatch.setattr('agent_tools.tool_trade.get_db_connection',
+                       lambda x: mock_conn)
+
+    # Mock get_current_position_from_db to return starting position
+    monkeypatch.setattr('agent_tools.tool_trade.get_current_position_from_db',
+                       lambda job_id, sig, date: ({'CASH': 500.0, 'AAPL': 10}, 0))
+
+    monkeypatch.setenv('RUNTIME_ENV_PATH', '/tmp/test_runtime_intraday.json')
+
+    import json
+    with open('/tmp/test_runtime_intraday.json', 'w') as f:
+        json.dump({
+            'TODAY_DATE': '2025-01-15',
+            'SIGNATURE': 'test-model',
+            'JOB_ID': 'test-job-123',
+            'TRADING_DAY_ID': trading_day_id
+        }, f)
+
+    # Mock prices: AAPL sells for 200, MSFT costs 150
+    def mock_get_prices(date, symbols):
+        if 'AAPL' in symbols:
+            return {'AAPL_price': 200.0}
+        elif 'MSFT' in symbols:
+            return {'MSFT_price': 150.0}
+        return {}
+
+    monkeypatch.setattr('agent_tools.tool_trade.get_open_prices', mock_get_prices)
+
+    # Step 1: Sell 3 shares of AAPL for 600.0
+    # Starting cash: 500.0, proceeds: 600.0, new cash: 1100.0
+    result_sell = _sell_impl(
+        symbol='AAPL',
+        amount=3,
+        signature='test-model',
+        today_date='2025-01-15',
+        job_id='test-job-123',
+        trading_day_id=trading_day_id,
+        _current_position=None  # Use database position (starting position)
+    )
+
+    assert 'error' not in result_sell, f"Sell should succeed: {result_sell}"
+    assert result_sell['CASH'] == 1100.0, "Cash should be 500 + (3 * 200) = 1100"
+    assert result_sell['AAPL'] == 7, "AAPL shares should be 10 - 3 = 7"
+
+    # Step 2: Buy 7 shares of MSFT for 1050.0 using the position from the sell
+    # This should work because we pass the updated position from step 1
+    result_buy = _buy_impl(
+        symbol='MSFT',
+        amount=7,
+        signature='test-model',
+        today_date='2025-01-15',
+        job_id='test-job-123',
+        trading_day_id=trading_day_id,
+        _current_position=result_sell  # Use position from sell
+    )
+
+    assert 'error' not in result_buy, f"Buy should succeed with sell proceeds: {result_buy}"
+    assert result_buy['CASH'] == 50.0, "Cash should be 1100 - (7 * 150) = 50"
+    assert result_buy['MSFT'] == 7, "MSFT shares should be 7"
+    assert result_buy['AAPL'] == 7, "AAPL shares should still be 7"
+
+    # Verify both actions were recorded
+    cursor = db.connection.execute("""
+        SELECT action_type, symbol, quantity, price
+        FROM actions
+        WHERE trading_day_id = ?
+        ORDER BY created_at
+    """, (trading_day_id,))
+
+    actions = cursor.fetchall()
+    assert len(actions) == 2, "Should have 2 actions (sell + buy)"
+    assert actions[0][0] == 'sell' and actions[0][1] == 'AAPL'
+    assert actions[1][0] == 'buy' and actions[1][1] == 'MSFT'
+
+
+def test_intraday_tracking_without_position_injection_fails(test_db, monkeypatch):
+    """Test that without position injection, sell proceeds are NOT available for subsequent buys."""
+    db, trading_day_id = test_db
+
+    # Setup: Create starting position with AAPL shares and limited cash
+    db.create_holding(trading_day_id, 'AAPL', 10)
+    db.connection.commit()
+
+    # Create a mock connection wrapper
+    class MockConnection:
+        def __init__(self, real_conn):
+            self.real_conn = real_conn
+
+        def cursor(self):
+            return self.real_conn.cursor()
+
+        def commit(self):
+            return self.real_conn.commit()
+
+        def rollback(self):
+            return self.real_conn.rollback()
+
+        def close(self):
+            pass
+
+    mock_conn = MockConnection(db.connection)
+    monkeypatch.setattr('agent_tools.tool_trade.get_db_connection',
+                       lambda x: mock_conn)
+
+    # Mock get_current_position_from_db to ALWAYS return starting position
+    # (simulating the old buggy behavior)
+    monkeypatch.setattr('agent_tools.tool_trade.get_current_position_from_db',
+                       lambda job_id, sig, date: ({'CASH': 500.0, 'AAPL': 10}, 0))
+
+    monkeypatch.setenv('RUNTIME_ENV_PATH', '/tmp/test_runtime_no_injection.json')
+
+    import json
+    with open('/tmp/test_runtime_no_injection.json', 'w') as f:
+        json.dump({
+            'TODAY_DATE': '2025-01-15',
+            'SIGNATURE': 'test-model',
+            'JOB_ID': 'test-job-123',
+            'TRADING_DAY_ID': trading_day_id
+        }, f)
+
+    # Mock prices
+    def mock_get_prices(date, symbols):
+        if 'AAPL' in symbols:
+            return {'AAPL_price': 200.0}
+        elif 'MSFT' in symbols:
+            return {'MSFT_price': 150.0}
+        return {}
+
+    monkeypatch.setattr('agent_tools.tool_trade.get_open_prices', mock_get_prices)
+
+    # Step 1: Sell 3 shares of AAPL
+    result_sell = _sell_impl(
+        symbol='AAPL',
+        amount=3,
+        signature='test-model',
+        today_date='2025-01-15',
+        job_id='test-job-123',
+        trading_day_id=trading_day_id,
+        _current_position=None  # Don't inject position (old behavior)
+    )
+
+    assert 'error' not in result_sell, "Sell should succeed"
+
+    # Step 2: Try to buy 7 shares of MSFT WITHOUT passing updated position
+    # This should FAIL because it will query the database and get the original 500.0 cash
+    result_buy = _buy_impl(
+        symbol='MSFT',
+        amount=7,
+        signature='test-model',
+        today_date='2025-01-15',
+        job_id='test-job-123',
+        trading_day_id=trading_day_id,
+        _current_position=None  # Don't inject position (old behavior)
+    )
+
+    # This should fail with insufficient cash
+    assert 'error' in result_buy, "Buy should fail without position injection"
+    assert result_buy['error'] == 'Insufficient cash', f"Expected insufficient cash error, got: {result_buy}"
+    assert result_buy['cash_available'] == 500.0, "Should see original cash, not updated cash"