codex-agent-framework 0.1.27__tar.gz → 0.1.28__tar.gz

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file.
 
 This project loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and uses semantic versioning where practical.
 
+## [0.1.28] - 2026-05-15
+### Added
+- Add `StreamManager` as a dedicated stream-processing manager and expose it through the package API.
+
+### Changed
+- Improve Textual TUI streaming performance with coalesced replay/live deltas and safer incremental rendering.
+- Make terminal resize handling re-render the TUI transcript and status cleanly.
+- Treat the worker status cache as the single status source of truth, with process fallback limited to bootstrap.
+
+### Fixed
+- Keep `/status`, context providers, and the TUI status bar aligned after worker restarts and busy turns.
+- Preserve wrapper/message partition counters and token splits across context builds, API status updates, and restarts.
+- Avoid status update events confusing stale-turn detection.
+
+### Tests
+- Expand regression coverage for status cache replication, fallback bootstrap behavior, wrapper partitions, TUI delta batching, replay coalescing, and resize handling; the current suite validates at 576 passed.
+
 ## [0.1.25] - 2026-05-12
 ### Added
 - Add bundled plugin `requirements.txt` metadata for built-in capabilities and move image generation, realtime voice, and TTS into plugin-scoped packages.

{codex_agent_framework-0.1.27/codex_agent_framework.egg-info → codex_agent_framework-0.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.27
+Version: 0.1.28
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/codex_agent/__init__.py

@@ -60,7 +60,7 @@ from .image import ImageMessage
 from .mainloop import MainLoopManager
 from .plugin import Plugin, PluginsManager, event_handler, hook_handler, stream_processor
 from .command import AgentCommand, AgentFuture, AgentTurn, CommandManager, command
-from .stream import AgentStream
+from .stream import AgentStream, StreamManager
 from .provider import ProvidersManager, provider
 from .runtime import RuntimeManager
 from .sessions import AgentSession, SessionsManager
@@ -138,6 +138,7 @@ __all__ = [
     "AgentFuture",
     "AgentTurn",
     "AgentStream",
+    "StreamManager",
     "CommandManager",
     "command",
     "provider",

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/codex_agent/agent.py

@@ -14,6 +14,7 @@ from .runtime import RuntimeManager
 from .scheduler import AgentScheduler
 from .sessions import SessionsManager
 from .status import StatusManager
+from .stream import StreamManager
 from .tool import ToolsManager, reset_current_agent, set_current_agent
 from .ai import AIClient
 from .event import AssistantInterruptRequestedEvent, AssistantInterrupted, AssistantInterruptedEvent, EventBus
@@ -32,26 +33,20 @@ class Agent:
         ensure_runtime_dir()
         self.init_execution_environment()
         self.config_manager=ConfigManager(self)
-        self.config=self.config_manager.config
         self.config_manager.load()
         self.config_manager.update(kwargs, save=False)
         self.config_manager.apply_openai_capability_defaults()
         self.events=EventBus()
         self.tools_manager=ToolsManager(self)
-        self.tools=self.tools_manager.tools
         self.providers_manager=ProvidersManager(self)
-        self.providers=self.providers_manager.providers
         self.command_manager=CommandManager(self)
-        self.commands=self.command_manager.commands
         self.context_manager=ContextManager(self)
         self.plugins_manager=PluginsManager(self)
-        self.plugins=self.plugins_manager.plugins
         self.sessions_manager=SessionsManager(self)
         self.runtime=RuntimeManager(self)
         self.scheduler=AgentScheduler(self)
         self.hooks=HookManager(self)
-        self.stream_processors=modict()
-        self.stream_processor_owners={}
+        self.stream_manager=StreamManager(self)
         self.mainloop_manager=MainLoopManager(self)
         self._interrupt_requested=ThreadEvent()
         self.current_session_id=None
@@ -86,6 +81,40 @@ class Agent:
             mainloop_manager.record_event(event)
         return event
 
+    @property
+    def config(self):
+        return self.config_manager.config
+
+    @config.setter
+    def config(self, value):
+        self.config_manager.config = value
+        if hasattr(self.config_manager, "configs"):
+            self.config_manager.configs.agent = value
+
+    @property
+    def tools(self):
+        return self.tools_manager.tools
+
+    @property
+    def providers(self):
+        return self.providers_manager.providers
+
+    @property
+    def commands(self):
+        return self.command_manager.commands
+
+    @property
+    def plugins(self):
+        return self.plugins_manager.plugins
+
+    @property
+    def stream_processors(self):
+        return self.stream_manager.processors
+
+    @property
+    def stream_processor_owners(self):
+        return self.stream_manager.owners
+
     @property
     def busy(self):
         return self.mainloop_manager.busy
@@ -274,32 +303,13 @@ class Agent:
         return self.plugins_manager.reload_plugin(plugin_or_name, timeout=timeout)
 
     def add_stream_processor(self, key, processor, owner=None):
-        processors = self.stream_processors.setdefault(str(key), [])
-        processors.append(processor)
-        if owner is not None:
-            self.stream_processor_owners.setdefault(str(key), {})[processor] = owner
-        return processor
+        return self.stream_manager.add(key, processor, owner=owner)
 
     def get_stream_processors(self, key):
-        return list(self.stream_processors.get(str(key), []))
+        return self.stream_manager.get(key)
 
     def remove_stream_processors_by_owner(self, owner):
-        removed = modict()
-        for key, processors in list(self.stream_processors.items()):
-            owners = self.stream_processor_owners.get(key, {})
-            kept = []
-            for processor in processors:
-                if owners.get(processor) == owner:
-                    removed.setdefault(key, []).append(processor)
-                    owners.pop(processor, None)
-                else:
-                    kept.append(processor)
-            if kept:
-                self.stream_processors[key] = kept
-            else:
-                self.stream_processors.pop(key, None)
-                self.stream_processor_owners.pop(key, None)
-        return removed
+        return self.stream_manager.remove_by_owner(owner)
 
     def add_hook(self, key, func=None, owner=None):
         """Register a runtime hook.

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/codex_agent/agent_runtime.py

@@ -8,8 +8,11 @@ from abc import ABC, abstractmethod
 from modict import modict
 
 from .agent import Agent
+from .config import AgentConfig
 from .event import Event
-from .message import UserMessage, message_from_data
+from .message import ToolResultWrapper, UserMessage, message_from_data
+from .sessions import AgentSession
+from .utils import token_count, truncate
 
 
 def jsonable(value):
@@ -270,13 +273,38 @@ class ProcessAgentRuntime(AgentRuntime):
             current_turn_id=None,
             current_session_id=None,
             status=modict(),
-            config=modict(),
+            config=AgentConfig(),
             session=modict(),
             sessions=modict(current=None, sessions=[]),
             messages=[],
             tools=modict(),
             wakeups=[],
         )
+        self.hydrate_local_session_cache()
+
+    def local_session_id(self):
+        session_id = self.agent_kwargs.get("session")
+        if not session_id or session_id == "latest":
+            try:
+                sessions = AgentSession.list_sessions()
+            except Exception:
+                return None
+            return sessions[0] if sessions else None
+        return session_id if AgentSession.can_load(session_id) else None
+
+    def hydrate_local_session_cache(self):
+        session_id = self.local_session_id()
+        if not session_id:
+            return False
+        try:
+            session = AgentSession.load(session_id)
+        except Exception:
+            return False
+        self.cache.current_session_id = session.session_id
+        self.cache.session = session
+        self.cache.messages = list(session.messages)
+        self.refresh_cached_wrapper_status(hydrate=False)
+        return True
 
     def start(self):
         with self.start_lock:
@@ -293,6 +321,7 @@ class ProcessAgentRuntime(AgentRuntime):
             self.process.start()
             self.event_thread = threading.Thread(target=self._event_loop, name="agent-runtime-events", daemon=True)
             self.event_thread.start()
+            self.hydrate_local_session_cache()
             try:
                 self.call("start", timeout=self.command_timeout, autostart=False)
                 self.refresh_cache()
@@ -339,6 +368,8 @@ class ProcessAgentRuntime(AgentRuntime):
             except Exception:
                 pass
         self.update_status_cache(self.cache.get("status") or {})
+        if not self.cache.get("status"):
+            self.refresh_cached_wrapper_status()
         return self.cache
 
     def call(self, name, payload=None, timeout=None, autostart=True):
@@ -391,6 +422,107 @@ class ProcessAgentRuntime(AgentRuntime):
         self.cache.current_session_id = status.get("session_id", self.cache.current_session_id)
         return status
 
+    def cached_message_from_event(self, message):
+        if not message:
+            return None
+        try:
+            return message_from_data(message)
+        except Exception:
+            return modict(message)
+
+    def is_cached_wrapper(self, message):
+        if isinstance(message, ToolResultWrapper):
+            return True
+        types = message.get("types") or []
+        return message.get("type") == "tool_result_wrapper" or "tool_result_wrapper" in types
+
+    def cached_wrapper_tokens(self, messages):
+        total = 0
+        config = modict(self.cache.get("config") or {})
+        max_tokens = int(config.get("max_input_tokens", 8000) or 8000)
+        model = config.get("model")
+        for message in messages:
+            content = message.get("content")
+            if not isinstance(content, str) or not content:
+                continue
+            total += token_count(truncate(content, max_tokens=max_tokens, model=model), model=model)
+        return total
+
+    def refresh_cached_wrapper_status(self, hydrate=True):
+        status = modict(self.cache.status or {})
+        if hydrate and not self.cache.get("messages"):
+            self.hydrate_local_session_cache()
+        messages = list(self.cache.get("messages") or [])
+        wrappers = [message for message in messages if self.is_cached_wrapper(message)]
+        active = [
+            message for message in wrappers
+            if isinstance(message.get("turns_left", -1), int) and message.get("turns_left", -1) > 0
+        ]
+        vanished = [message for message in wrappers if message.get("turns_left", -1) == 0]
+        active_tokens = self.cached_wrapper_tokens(active)
+        vanished_tokens = self.cached_wrapper_tokens(vanished)
+        visible_non_wrappers = [
+            message for message in messages
+            if not self.is_cached_wrapper(message) and message.get("turns_left", -1) != 0
+        ]
+        estimated_base_tokens = self.cached_wrapper_tokens(visible_non_wrappers)
+        # The fallback cache is updated by message events while the worker may be busy. Do not preserve
+        # a stale worker-provided context_current_tokens here: otherwise wrapper/message counts move but
+        # the context percentage appears frozen until a full worker status succeeds.
+        current_tokens = estimated_base_tokens + active_tokens
+        persistent = [message for message in messages if message.get("turns_left", -1) == -1]
+        temporary = [
+            message for message in messages
+            if isinstance(message.get("turns_left", -1), int) and message.get("turns_left", -1) > 0
+        ]
+        config = modict(self.cache.get("config") or {})
+        input_limit = int(status.get("context_limit_tokens") or config.get("input_token_limit", 0) or 0)
+        if not current_tokens:
+            current_tokens = estimated_base_tokens + active_tokens
+        base_tokens = max(0, current_tokens - active_tokens) if current_tokens else estimated_base_tokens
+        status.update(
+            context_current_tokens=current_tokens,
+            context_limit_tokens=input_limit,
+            context_percent=(current_tokens / input_limit * 100) if input_limit else 0,
+            model=status.get("model") or config.get("model"),
+            source="process_fallback",
+            total_session_messages=len(messages) or status.get("total_session_messages", 0),
+            persistent_session_messages=len(persistent),
+            temporary_session_messages=len(temporary),
+            active_wrapper_messages=len(active),
+            vanished_wrapper_messages=len(vanished),
+            total_wrapper_messages=len(wrappers),
+            active_wrapper_tokens=active_tokens,
+            vanished_wrapper_tokens=vanished_tokens,
+            base_context_tokens=base_tokens,
+        )
+        self.cache.status = status
+        return status
+
+    def has_worker_status_cache(self):
+        status = modict(self.cache.get("status") or {})
+        source = status.get("source")
+        return bool(source) and source != "process_fallback"
+
+    def append_cached_message(self, message):
+        message = self.cached_message_from_event(message)
+        if message is None:
+            return None
+        self.cache.messages.append(message)
+        if not self.has_worker_status_cache():
+            return self.refresh_cached_wrapper_status()
+        return self.cache.status
+
+    def age_cached_context_messages(self):
+        changed = False
+        for message in self.cache.get("messages") or []:
+            turns_left = message.get("turns_left", -1)
+            if isinstance(turns_left, int) and turns_left > 0:
+                message.turns_left = turns_left - 1
+                changed = True
+        if changed and not self.has_worker_status_cache():
+            self.refresh_cached_wrapper_status()
+
     def mark_turn_started(self, turn_id=None):
         self.cache.busy = True
         if turn_id is not None:
@@ -404,12 +536,22 @@ class ProcessAgentRuntime(AgentRuntime):
         event_type = event.get("type")
         if event_type == "assistant_turn_start_event":
             self.mark_turn_started(event.get("turn_id"))
+            self.age_cached_context_messages()
         elif event_type in ("assistant_turn_end_event", "assistant_turn_error_event"):
             self.mark_turn_finished()
+        elif event_type == "message_added_event":
+            message = self.cached_message_from_event(event.get("message"))
+            if message is not None:
+                self.cache.messages.append(message)
+                if not self.has_worker_status_cache():
+                    self.refresh_cached_wrapper_status()
         elif event_type == "session_loaded_event":
             self.cache.current_session_id = event.get("session_id")
             self.cache.session = event.get("session") or self.cache.session
-        elif event_type == "compaction_completed_event" and event.get("status"):
+            self.cache.messages = list((self.cache.session or {}).get("messages") or [])
+            if not self.has_worker_status_cache():
+                self.refresh_cached_wrapper_status()
+        elif event_type in ("status_updated_event", "compaction_completed_event") and event.get("status"):
             self.update_status_cache(event.status)
         for handler in list(self.event_handlers):
             try:
@@ -434,8 +576,13 @@ class ProcessAgentRuntime(AgentRuntime):
             return self.update_status_cache(self.call("get_status", timeout=self.status_timeout))
         except Exception:
             status = modict(self.cache.status or {})
-            status.setdefault("busy", self.cache.busy)
-            status.setdefault("current_turn_id", self.cache.current_turn_id)
+            if not self.has_worker_status_cache():
+                status = self.refresh_cached_wrapper_status()
+            status.update(
+                busy=self.cache.busy,
+                current_turn_id=self.cache.current_turn_id,
+                session_id=self.cache.current_session_id,
+            )
             return status
 
     def config(self):

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/codex_agent/context.py

@@ -1,7 +1,7 @@
 from modict import modict
 
 from .image import ImageMessage
-from .message import Message, ProviderMessage, SystemMessage
+from .message import Message, ProviderMessage, SystemMessage, ToolResultWrapper
 from .tool import reset_current_agent, set_current_agent
 from .utils import sort, token_count_payload, truncate
 
@@ -100,14 +100,45 @@ class ContextManager:
         formatted_context = list(msg.format(context=self.agent.context_namespace) for msg in context)
         total_session_messages = len(self.agent.session.messages) if self.agent.session else 0
         sent_session_messages = len(history) + len(images)
+        all_session_messages = list(self.agent.session.messages) if self.agent.session else []
         persistent_session_messages = sum(
-            1 for msg in session_messages
+            1 for msg in all_session_messages
             if msg.get("turns_left", -1) == -1
         )
         temporary_session_messages = sum(
-            1 for msg in session_messages
+            1 for msg in all_session_messages
             if isinstance(msg.get("turns_left", -1), int) and msg.get("turns_left", -1) > 0
         )
+        wrappers = [msg for msg in all_session_messages if isinstance(msg, ToolResultWrapper)]
+        active_wrappers = [
+            msg for msg in wrappers
+            if isinstance(msg.get("turns_left", -1), int) and msg.get("turns_left", -1) > 0
+        ]
+        vanished_wrappers = [msg for msg in wrappers if msg.get("turns_left", -1) == 0]
+
+        def wrapper_token_count(messages):
+            total = 0
+            for msg in messages:
+                total += self.response_input_token_count([msg], response_tools=[])
+            return total
+
+        active_context_wrappers = [msg for msg in history if isinstance(msg, ToolResultWrapper)]
+        active_wrapper_tokens = wrapper_token_count(active_context_wrappers)
+        vanished_wrapper_tokens = wrapper_token_count(vanished_wrappers)
+        base_context_tokens = max(0, current_count - active_wrapper_tokens)
+        if self.agent.session:
+            compaction_plan = self.agent.session.compaction_plan(
+                max_input_tokens=max_input_tokens,
+                model=self.agent.config.model,
+                max_compacted_turns=None,
+            )
+            compactable_turns = compaction_plan.completed_turn_count
+            compactable_messages = compaction_plan.compacted_message_count
+            compactable_tokens = compaction_plan.compacted_token_count
+        else:
+            compactable_turns = 0
+            compactable_messages = 0
+            compactable_tokens = 0
         token_count_source = "local_estimate"
         try:
             current_count = self.agent.ai.count_input_tokens(
@@ -125,6 +156,15 @@ class ContextManager:
             sent_session_message_percent=(sent_session_messages / total_session_messages * 100) if total_session_messages else 0,
             persistent_session_messages=persistent_session_messages,
             temporary_session_messages=temporary_session_messages,
+            active_wrapper_messages=len(active_wrappers),
+            vanished_wrapper_messages=len(vanished_wrappers),
+            total_wrapper_messages=len(wrappers),
+            base_context_tokens=base_context_tokens,
+            active_wrapper_tokens=active_wrapper_tokens,
+            vanished_wrapper_tokens=vanished_wrapper_tokens,
+            compactable_turns=compactable_turns,
+            compactable_messages=compactable_messages,
+            compactable_tokens=compactable_tokens,
             token_count_source=token_count_source,
         ))
         hook = self.agent.run_hook("context.build.after", messages=formatted_context)

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/codex_agent/event.py

@@ -102,6 +102,10 @@ class MessageAddedEvent(Event):
     message = None
 
 
+class StatusUpdatedEvent(Event):
+    status = None
+
+
 class MessageSubmittedEvent(Event):
     message = None
     turn_id = None

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/codex_agent/server/core.py

@@ -396,9 +396,13 @@ class AgentServer:
 
     def event_stream_status(self, stale_timeout=120):
         with self.event_lock:
-            last_event = self.events[-1] if self.events else None
             active = bool(self.turn_replay_active)
             current_turn_events = list(self.current_turn_events)
+            source_events = current_turn_events if current_turn_events else list(self.events)
+            last_event = next(
+                (event for event in reversed(source_events) if event.get("type") != "status_updated_event"),
+                None,
+            )
         last_timestamp = self.event_timestamp(last_event)
         now = time.time()
         return modict(

{codex_agent_framework-0.1.27 → codex_agent_framework-0.1.28}/codex_agent/status.py

@@ -1,5 +1,6 @@
 from modict import modict
 
+from .event import StatusUpdatedEvent
 from .image import ImageMessage
 from .message import ToolResultWrapper
 from .utils import sort, truncate
@@ -12,11 +13,48 @@ class StatusManager:
         self.context_status_cache = None
         self.wham_status_loaded = False
 
+    def publish_status_cache(self):
+        if self.status_cache is not None:
+            self.agent.emit(StatusUpdatedEvent, status=self.status_cache)
+        return self.status_cache
+
+    def status_from_context_status(self, context_status):
+        previous = modict(self.status_cache or {})
+        return modict(
+            context_current_tokens=context_status.used_tokens,
+            context_limit_tokens=context_status.input_token_limit,
+            context_percent=context_status.percent,
+            sent_session_messages=context_status.sent_session_messages,
+            total_session_messages=context_status.total_session_messages,
+            sent_session_message_percent=context_status.sent_session_message_percent,
+            persistent_session_messages=context_status.get("persistent_session_messages", 0),
+            temporary_session_messages=context_status.get("temporary_session_messages", 0),
+            active_wrapper_messages=context_status.get("active_wrapper_messages", 0),
+            vanished_wrapper_messages=context_status.get("vanished_wrapper_messages", 0),
+            total_wrapper_messages=context_status.get("total_wrapper_messages", 0),
+            base_context_tokens=context_status.get("base_context_tokens", context_status.used_tokens),
+            active_wrapper_tokens=context_status.get("active_wrapper_tokens", 0),
+            vanished_wrapper_tokens=context_status.get("vanished_wrapper_tokens", 0),
+            compactable_turns=context_status.get("compactable_turns", 0),
+            compactable_messages=context_status.get("compactable_messages", 0),
+            compactable_tokens=context_status.get("compactable_tokens", 0),
+            quota_5h_percent=previous.get("quota_5h_percent"),
+            quota_7d_percent=previous.get("quota_7d_percent"),
+            model=previous.get("model") or self.agent.config.get("model") or "gpt-5.4",
+            busy=self.agent.mainloop_manager.busy,
+            current_turn_id=self.agent.mainloop_manager.current_turn_id,
+            session_id=self.agent.current_session_id,
+            source=context_status.get("token_count_source", "estimated"),
+            activity=self.agent.mainloop_manager.activity_status(),
+        )
+
     def invalidate_context_cache(self):
         self.context_status_cache = None
 
     def cache_context_status(self, status):
         self.context_status_cache = status
+        self.status_cache = self.status_from_context_status(status)
+        self.publish_status_cache()
         return status
 
     def estimated_context_status(self):
@@ -66,11 +104,11 @@ class StatusManager:
         sent_session_messages = visible_history_count + len(images)
         total_session_messages = len(self.agent.session.messages) if self.agent.session else 0
         persistent_session_messages = sum(
-            1 for msg in session_messages
+            1 for msg in all_session_messages
             if msg.get("turns_left", -1) == -1
         )
         temporary_session_messages = sum(
-            1 for msg in session_messages
+            1 for msg in all_session_messages
             if isinstance(msg.get("turns_left", -1), int) and msg.get("turns_left", -1) > 0
         )
         wrappers = [msg for msg in all_session_messages if isinstance(msg, ToolResultWrapper)]
@@ -142,44 +180,16 @@ class StatusManager:
     def get_status(self):
         if self.status_cache is None and not self.wham_status_loaded:
             self.refresh_wham_status()
-        if self.status_cache is not None:
-            status = self.status_cache.copy()
-            status.update(
-                busy=self.agent.mainloop_manager.busy,
-                current_turn_id=self.agent.mainloop_manager.current_turn_id,
-                session_id=self.agent.current_session_id,
-                activity=self.agent.mainloop_manager.activity_status(),
-            )
-            return status
-
-        estimated = self.estimated_context_status()
-        return modict(
-            context_current_tokens=estimated.used_tokens,
-            context_limit_tokens=estimated.input_token_limit,
-            context_percent=estimated.percent,
-            sent_session_messages=estimated.sent_session_messages,
-            total_session_messages=estimated.total_session_messages,
-            sent_session_message_percent=estimated.sent_session_message_percent,
-            persistent_session_messages=estimated.get("persistent_session_messages", 0),
-            temporary_session_messages=estimated.get("temporary_session_messages", 0),
-            active_wrapper_messages=estimated.get("active_wrapper_messages", 0),
-            vanished_wrapper_messages=estimated.get("vanished_wrapper_messages", 0),
-            total_wrapper_messages=estimated.get("total_wrapper_messages", 0),
-            base_context_tokens=estimated.get("base_context_tokens", estimated.used_tokens),
-            active_wrapper_tokens=estimated.get("active_wrapper_tokens", 0),
-            vanished_wrapper_tokens=estimated.get("vanished_wrapper_tokens", 0),
-            compactable_turns=estimated.get("compactable_turns", 0),
-            compactable_messages=estimated.get("compactable_messages", 0),
-            compactable_tokens=estimated.get("compactable_tokens", 0),
-            quota_5h_percent=None,
-            quota_7d_percent=None,
-            model=self.agent.config.get("model") or "gpt-5.4",
+        if self.status_cache is None:
+            self.context_status()
+        status = modict(self.status_cache or {})
+        status.update(
             busy=self.agent.mainloop_manager.busy,
             current_turn_id=self.agent.mainloop_manager.current_turn_id,
             session_id=self.agent.current_session_id,
-            source=estimated.get("token_count_source", "estimated"),
             activity=self.agent.mainloop_manager.activity_status(),
         )
+        return status
 
     def refresh_wham_status(self):
         self.wham_status_loaded = True
@@ -215,10 +225,11 @@ class StatusManager:
                 activity=self.agent.mainloop_manager.activity_status(),
             )
         self.status_cache.update(wham)
+        self.publish_status_cache()
         return wham
 
     def refresh_estimated_status_cache(self):
-        estimated = self.estimated_context_status()
+        estimated = self.context_status()
         if self.status_cache is None:
             return estimated
         previous = self.status_cache.copy()
@@ -240,7 +251,7 @@ class StatusManager:
             compactable_turns=estimated.get("compactable_turns", 0),
             compactable_messages=estimated.get("compactable_messages", 0),
             compactable_tokens=estimated.get("compactable_tokens", 0),
-            model=self.agent.config.get("model") or "gpt-5.4",
+            model=previous.get("model") or self.agent.config.get("model") or "gpt-5.4",
             busy=self.agent.mainloop_manager.busy,
             current_turn_id=self.agent.mainloop_manager.current_turn_id,
             session_id=self.agent.current_session_id,
@@ -250,6 +261,7 @@ class StatusManager:
         previous.setdefault("quota_5h_percent", None)
         previous.setdefault("quota_7d_percent", None)
         self.status_cache = previous
+        self.publish_status_cache()
         return self.status_cache
 
     def cache_api_status(self, usage=None, model=None, quota=None):
@@ -269,7 +281,7 @@ class StatusManager:
             active_wrapper_messages=context_status.get("active_wrapper_messages", 0),
             vanished_wrapper_messages=context_status.get("vanished_wrapper_messages", 0),
             total_wrapper_messages=context_status.get("total_wrapper_messages", 0),
-            base_context_tokens=context_status.get("base_context_tokens", max(0, input_tokens)),
+            base_context_tokens=max(0, input_tokens - context_status.get("active_wrapper_tokens", 0)),
             active_wrapper_tokens=context_status.get("active_wrapper_tokens", 0),
             vanished_wrapper_tokens=context_status.get("vanished_wrapper_tokens", 0),
             compactable_turns=context_status.get("compactable_turns", 0),
@@ -284,6 +296,7 @@ class StatusManager:
             source="last_api_call",
             activity=self.agent.mainloop_manager.activity_status(),
         )
+        self.publish_status_cache()
         return self.status_cache
 
     def wham_status(self, quota=None):