fix(cli): foreground the WebUI browser

README.md

@@ -146,7 +146,7 @@ Activate it with `source .venv/bin/activate` on macOS/Linux or
 python -m pip install -e .
 ```
 
-After that, the normal commands are identical to a stable install. `nanobot` runs the TUI
+After that, the normal commands are identical to a stable install. `nanobot agent` runs the TUI
 from this checkout, and `nanobot webui` rebuilds stale frontend assets automatically. A later
 `git pull --ff-only` updates the Python, TUI, and WebUI source together; rerun
 `python -m pip install -e .` when Python dependencies change. Contributors should also read
@@ -206,10 +206,10 @@ Use `nanobot gateway --background` for the same direct entry point without keepi
 **Prefer to work entirely in the terminal?**
 
 ```bash
-nanobot
+nanobot agent
 ```
 
-This opens the native terminal client with the launch directory as its workspace. It shares saved conversations and the local gateway with the WebUI. The explicit `nanobot agent` form remains available for compatibility.
+This opens the native terminal client with the launch directory as its workspace. It shares saved conversations and the local gateway with the WebUI.
 
 - Type `/` to discover commands, `/sessions` to switch conversations, or `@` to mention an app, MCP server, or saved session.
 - Press `Enter` to send. While nanobot is working, `Enter` sends now and `Tab` sends after the current response. Press `Shift+Enter` to add a newline (`Ctrl+J` works in terminals that cannot distinguish modified Enter keys).
@@ -220,7 +220,7 @@ Each launch starts a new session by default. Use `--session` to resume one and `
 For one request and an immediate exit, use:
 
 ```bash
-nanobot -m "Hello!"
+nanobot agent -m "Hello!"
 ```
 
 The one-shot form is useful for a quick provider check, shell scripts, and local automation. If you have not configured a model yet, run `nanobot webui` and open **Settings → Models** first.

docs/cli-reference.md

@@ -12,8 +12,8 @@ Use this page when you know what you want to run and need the command shape. For
 | Use guided setup | `nanobot onboard --wizard` | Best when you prefer prompts over hand-editing JSON |
 | Open the browser workbench | `nanobot webui` | Prepares local WebUI settings, starts the gateway, and opens the browser |
 | Check readiness without calling a model | `nanobot status` | Summarizes config/workspace and validates the active provider/model configuration |
-| Send one test message | `nanobot -m "Hello!"` | First proof that install, config, provider, model, and workspace all work |
-| Chat in the terminal | `nanobot` | Interactive local chat; `nanobot agent` remains an explicit alias |
+| Send one test message | `nanobot agent -m "Hello!"` | First proof that install, config, provider, model, and workspace all work |
+| Chat in the terminal | `nanobot agent` | Interactive local chat; exit with `exit`, `/exit`, `:q`, or `Ctrl+D` |
 | Run the gateway directly | `nanobot gateway` | Service/ops command for WebUI, chat apps, cron, and heartbeat |
 | Deliver a local trigger | `nanobot trigger <id> "message"` | Created first with `/trigger <name>` in the target chat/session |
 | Serve an OpenAI-compatible API | `nanobot serve` | Starts `/v1/chat/completions`, `/v1/models`, and `/health` |
@@ -86,15 +86,15 @@ follow the printed WebUI **Settings → Models** or `nanobot onboard --wizard` r
 
 | Command | Description |
 |---|---|
-| `nanobot -m "Hello!"` | Send one message and exit |
-| `nanobot` | Start interactive terminal chat |
-| `nanobot --session <id>` | Use a WebSocket session key; add `--classic` for another channel |
-| `nanobot --workspace <path>` | Override workspace |
-| `nanobot --config <path>` | Use a specific config file |
-| `nanobot --classic` | Use the classic Python prompt instead of the native terminal UI |
-| `nanobot --theme auto\|dark\|light` | Auto-detect the terminal appearance or force a TUI palette |
-| `nanobot --no-markdown` | Use the classic prompt and print plain text instead of Markdown |
-| `nanobot --logs` | Use the classic prompt and show runtime logs while chatting |
+| `nanobot agent -m "Hello!"` | Send one message and exit |
+| `nanobot agent` | Start interactive terminal chat |
+| `nanobot agent --session <id>` | Use a WebSocket session key; add `--classic` for another channel |
+| `nanobot agent --workspace <path>` | Override workspace |
+| `nanobot agent --config <path>` | Use a specific config file |
+| `nanobot agent --classic` | Use the classic Python prompt instead of the native terminal UI |
+| `nanobot agent --theme auto\|dark\|light` | Auto-detect the terminal appearance or force a TUI palette |
+| `nanobot agent --no-markdown` | Use the classic prompt and print plain text instead of Markdown |
+| `nanobot agent --logs` | Use the classic prompt and show runtime logs while chatting |
 
 Inside the native TUI, `/sessions` switches saved conversations, `/new-chat` starts another saved
 conversation, and `/context` explains the compacted summary and raw session suffix available to
@@ -139,7 +139,7 @@ Interactive mode exits with `exit`, `quit`, `/exit`, `/quit`, `:q`, or `Ctrl+D`.
 
 | Command | Description |
 |---|---|
-| `nanobot webui` | Create config/workspace if needed, enable the local WebUI channel after confirmation, start the gateway, open `http://127.0.0.1:8765`, and follow new gateway logs |
+| `nanobot webui` | Create config/workspace if needed, enable the local WebUI channel after confirmation, start the gateway, and open `http://127.0.0.1:8765` |
 | `nanobot webui --background` | Deprecated; prints the equivalent explicit `nanobot gateway --background` command and exits |
 | `nanobot webui --dev` | Start the gateway and Vite together at `http://127.0.0.1:5173`, with live frontend updates |
 | `nanobot webui --no-open` | Prepare and start the WebUI without opening a browser |
@@ -344,7 +344,7 @@ remain accepted as no-op compatibility aliases.
 | Command | Description |
 |---|---|
 | `nanobot provider login openai-codex --set-main` | Authenticate Codex and select its current default model |
-| `nanobot provider login xai-grok --set-main` | Authenticate an eligible X Premium / Grok subscription and select Grok 4.6; hosted X Search is enabled for models that advertise support |
+| `nanobot provider login xai-grok --set-main` | Authenticate an eligible X Premium / Grok subscription and select Grok 4.5; hosted X Search is enabled for models that advertise support |
 | `nanobot provider login github-copilot --set-main` | Authenticate GitHub Copilot and select its current default model |
 | `nanobot provider logout openai-codex` | Remove OpenAI Codex OAuth state |
 | `nanobot provider logout xai-grok --config <path>` | Remove the selected nanobot instance's xAI OAuth state |

docs/configuration.md

@@ -188,7 +188,7 @@ These variables are process-level switches. Set them in the same terminal, servi
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `NANOBOT_MAX_CONCURRENT_REQUESTS` | Unlimited | Maximum concurrently running inbound agent requests. Set a positive integer to apply a cap; unset, `0`, or a negative value means unlimited. |
+| `NANOBOT_MAX_CONCURRENT_REQUESTS` | `3` | Maximum concurrently running inbound agent requests. Must be an integer; set `0` or a negative value for unlimited. |
 | `NANOBOT_LLM_TIMEOUT_S` | `300` | Wall-clock timeout, in seconds. Ordinary requests use this value; streaming requests use the greater of 300 seconds or twice this value. Set `0` to disable. Sustained-goal turns bypass this wall-clock cap. |
 | `NANOBOT_STREAM_IDLE_TIMEOUT_S` | `90` | Streaming idle timeout, in seconds, used by streaming providers. Invalid or non-positive values are ignored; values above `3600` are clamped. |
 | `NANOBOT_OPENAI_COMPAT_TIMEOUT_S` | `120` | HTTP request timeout, in seconds, for OpenAI-compatible providers. Invalid or non-positive values are ignored. |
@@ -729,11 +729,6 @@ Then run:
 nanobot agent -m "Hello!"
 ```
 
-The WebUI model selector loads the models available to the signed-in account
-from Codex's online catalog. Context-window and reasoning-effort metadata come
-from that response; if discovery is unavailable, nanobot keeps a small built-in
-fallback instead of emptying the selector.
-
 Codex Fast mode can be enabled from the WebUI provider settings, or with:
 
 ```json
@@ -769,14 +764,11 @@ nanobot provider login xai-grok --set-main
 nanobot agent -m "Hello from Grok."
 ```
 
-The default model is `xai-grok/grok-4.6` with a 500,000-token context window.
-The provider reads and caches xAI's online model catalog for both WebUI model
-selection and runtime capabilities. Newly available models appear automatically;
-when discovery fails, the last successful catalog or built-in fallback remains
-available. The server-hosted `x_search` tool is included only when the selected
-model advertises support. Models without that capability continue normally
-without hosted X Search. When enabled, searches run inside xAI's Responses API
-and citations arrive as inline links.
+The default model is `xai-grok/grok-4.5` with a 500,000-token context window.
+The provider reads xAI's model catalog and includes the server-hosted `x_search`
+tool only when the selected model advertises `supportsBackendSearch`. Models
+without that capability continue normally without hosted X Search. When enabled,
+searches run inside xAI's Responses API and citations arrive as inline links.
 Hosted X Search is on by default to preserve this behavior. It can be turned off in the
 WebUI provider settings or with `providers.xaiGrok.extraBody.tools: []`.
 
@@ -813,10 +805,6 @@ a nanobot update.
 
 GitHub Copilot uses OAuth instead of API keys. Requires a [GitHub account with a plan](https://github.com/features/copilot/plans) configured. No `providers.github_copilot` block is needed in `config.json`; `nanobot provider login` stores the OAuth session outside config.
 
-After login, the WebUI loads the account-specific Copilot model catalog online.
-Only models compatible with nanobot's current chat-completions or Responses
-transport are shown.
-
 For GitHub Enterprise / Copilot for Business, set the endpoint overrides you need before login:
 ```bash
 export NANOBOT_GITHUB_COPILOT_CLIENT_ID="your-enterprise-client-id"
@@ -2225,7 +2213,7 @@ The notification gate runs on a built-in system prompt. Advanced users can overr
 
 ## Subagent Concurrency
 
-By default, nanobot allows four subagents to run at the same time. Additional subagents wait for capacity instead of being rejected. Lower the limit if a local model server cannot hold multiple KV caches, or raise it when the provider can handle more parallel work:
+By default, nanobot only allows one spawned subagent at a time. When the limit is reached, the `spawn` tool returns an error so the agent can decide to wait or rearrange its work. This protects local LLM servers from loading multiple KV caches at once. If your provider can handle more parallel work, raise the limit:
 
 ```json
 {
@@ -2241,7 +2229,7 @@ The deprecated `agents.defaults.failOnToolError` field is silently ignored when
 
 | Option | Default | Description |
 |--------|---------|-------------|
-| `agents.defaults.maxConcurrentSubagents` | `4` | Maximum number of subagents that may run at the same time. Additional tasks wait for capacity. |
+| `agents.defaults.maxConcurrentSubagents` | `1` | Maximum number of spawned subagents that may run at the same time. Attempts to spawn beyond this limit return an error. |
 
 
 ## Auto Compact
@@ -2268,12 +2256,16 @@ When a user is idle for longer than a configured threshold, nanobot **proactivel
 
 How it works:
 1. **Idle detection**: On each idle tick (~1 s), checks whether an idle-session scan is due. By default, the full scan runs at most once per minute.
-2. **Background compaction**: Older context is summarized while the most recent messages remain available.
-3. **Session preservation**: The complete session history remains stored for later inspection and reuse.
-4. **Restart-safe resume**: The compacted context remains available after a process restart.
+2. **Background compaction**: Idle sessions summarize the older live prefix via LLM and keep the most recent legal suffix (currently 8 messages).
+3. **Summary injection**: When the user returns, the summary is injected as runtime context (one-shot, not persisted) alongside the retained recent suffix.
+4. **Restart-safe resume**: The summary is also mirrored into session metadata so it can still be recovered after a process restart.
 
 > [!NOTE]
-> Auto compact shortens the context sent to the model without deleting the session's structured message history.
+> Mental model: "summarize older context, keep the freshest live turns, **and overwrite the session file with the compact form.**" It is not a full `session.clear()`, but it is a write — not a soft cursor move.
+>
+> Concretely, auto compact rewrites `sessions/<key>.jsonl` in place: older messages (including their structured `tool_calls` / `tool_call_id` / `reasoning_content`) are replaced by just the retained recent suffix (currently 8 messages), while the archived prefix is preserved only as a plain-text summary appended to `memory/history.jsonl` (or a `[RAW] ...` flattened dump if LLM summarization fails). The original structured JSON of those turns is no longer recoverable from the session file.
+>
+> This differs from the **token-driven soft consolidation** that fires when a prompt exceeds the context budget: that path only advances an internal `last_consolidated` cursor and leaves the session file untouched, so the raw tool-call trail stays on disk and can still be replayed or audited. If you rely on that trail for debugging or auditing, set `idleCompactAfterMinutes` to `0` and let only the token-driven path run.
 
 ## Timezone
 

docs/memory.md

@@ -29,7 +29,9 @@ Memory moves through nanobot in two stages.
 
 ### Stage 1: Consolidator
 
-When a conversation grows large, the `Consolidator` summarizes older turns and appends the result to `memory/history.jsonl`, while keeping recent conversation available. Each summary preserves useful long-term facts and a short handoff for active work.
+When a conversation grows large enough to pressure the context window, nanobot does not try to carry every old message forever.
+
+Instead, the `Consolidator` summarizes the oldest safe slice of the conversation and appends that summary to `memory/history.jsonl`.
 
 This file is:
 

docs/providers.md

@@ -572,23 +572,15 @@ For OpenAI Codex:
 nanobot provider login openai-codex --set-main
 ```
 
-The WebUI reads the account's Codex model catalog online, including current
-context-window and reasoning-effort metadata. A small compatible catalog remains
-available when the service cannot be reached.
-
 For an eligible X Premium / Grok subscription:
 
 ```bash
 nanobot provider login xai-grok --set-main
 ```
 
-This selects `xai-grok/grok-4.6`. The WebUI model selector reads xAI's online
-model catalog, so newly available subscription models appear without a nanobot
-release. Online metadata is cached and enriched with nanobot's curated labels;
-if xAI is temporarily unavailable, nanobot uses the last successful catalog or
-a small built-in fallback instead of emptying the selector. The same catalog
-controls whether the provider exposes the hosted `x_search` tool; models that do
-not advertise support continue without hosted X Search.
+This selects `xai-grok/grok-4.5`. The provider reads xAI's model catalog and
+exposes the hosted `x_search` tool only when the selected model advertises
+`supportsBackendSearch`; otherwise the model runs without hosted X Search.
 When enabled, Grok can search current X posts and return inline source links
 without invoking a local nanobot tool. Credentials are stored under the
 active instance's `auth/xai.json` (normally `~/.nanobot/auth/xai.json`), not in
@@ -607,10 +599,6 @@ For GitHub Copilot:
 nanobot provider login github-copilot --set-main
 ```
 
-The WebUI reads the models enabled for the signed-in Copilot account. nanobot
-lists entries that support its current Copilot chat-completions or Responses
-transport and hides models that it cannot route safely.
-
 Each command authenticates the selected provider and makes its current default model active. OpenAI Codex and eligible GitHub Copilot models participate in [Responses state retention](./configuration.md#responses-state-and-compaction), while native compaction remains provider-capability-specific. OAuth providers are not valid automatic fallbacks. See [`troubleshooting.md`](./troubleshooting.md#provider-and-model-problems) for proxy, headless-login, model-name, and config-key errors.
 
 ## Provider Resolution

docs/quick-start.md

@@ -103,13 +103,13 @@ Use `nanobot gateway logs`, `restart`, and `stop` to manage that background gate
 If you do not want the browser or need to isolate a WebUI problem, send one message directly:
 
 ```bash
-nanobot -m "Hello!"
+nanobot agent -m "Hello!"
 ```
 
 Then start an interactive terminal chat with:
 
 ```bash
-nanobot
+nanobot agent
 ```
 
 In interactive mode, `Enter` sends and `Shift+Enter` inserts a newline (`Ctrl+J` is the
@@ -173,7 +173,7 @@ nanobot webui
 ```
 
 The source path follows current `main` and can be newer than the published package. The editable
-install keeps Python pointed at the checkout; `nanobot` runs `tui/` with Bun, and
+install keeps Python pointed at the checkout; `nanobot agent` runs `tui/` with Bun, and
 `nanobot webui` automatically rebuilds `webui/` when its bundled assets are stale. All normal
 commands remain the same as a stable install. For development details, follow
 [`../CONTRIBUTING.md`](../CONTRIBUTING.md).

docs/webui.md

@@ -23,9 +23,7 @@ one is missing, starts or joins the same on-demand gateway used by the native
 TUI, and opens the browser. With a fresh config,
 it can open before a model is configured so you can finish setup in **Settings
 → Models**. The first-run path binds the WebUI to `127.0.0.1` by default, so
-it is not available from other devices on your LAN. While the launcher remains
-attached, it mirrors new log output from that exact gateway instance in the
-terminal without replaying older logs.
+it is not available from other devices on your LAN.
 
 After model setup, explicitly promote the shared gateway when you do not want to keep a client open:
 

nanobot/agent/autocompact.py

@@ -48,7 +48,7 @@ class AutoCompact:
 
     def _has_unarchived_messages(self, key: str) -> bool:
         session = self.sessions.get_or_create(key)
-        return session.last_archived < len(session.messages)
+        return session.last_consolidated < len(session.messages)
 
     @classmethod
     def _is_internal_session(cls, key: str) -> bool:

nanobot/agent/context.py

@@ -30,7 +30,11 @@ from nanobot.security.workspace_access import WorkspaceScopeResolver
 from nanobot.session.keys import last_channel_from_metadata
 from nanobot.session.manager import Session
 from nanobot.session.summary import SessionSummary
-from nanobot.utils.helpers import detect_image_mime, load_bundled_template
+from nanobot.utils.helpers import (
+    detect_image_mime,
+    load_bundled_template,
+    truncate_text_to_tokens,
+)
 from nanobot.utils.prompt_templates import render_template
 
 
@@ -71,29 +75,14 @@ class PersistedPromptContextResolver:
         return channel, scope.project_path
 
 
-@dataclass(frozen=True, slots=True)
-class TranscriptInput:
-    """Raw turn inputs from which ``ContextBuilder`` assembles a transcript."""
-
-    history: list[dict[str, Any]]
-    current_message: str | None
-    media: Sequence[str] | None = None
-    current_role: str = "user"
-    session_summary: SessionSummary | None = None
-    runtime_context_blocks: Sequence[RuntimeContextBlock] | None = None
-
-    @property
-    def message_count(self) -> int:
-        """Number of boundary-preserving messages in the assembled transcript."""
-        return 1 + len(self.history) + (self.current_message is not None)
-
-
 class ContextBuilder:
     """Builds the context (system prompt + messages) for the agent."""
 
     BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md"]
     _SKIPPABLE_DEFAULTS = {"AGENTS.md", "USER.md"}
     _RUNTIME_CONTEXT_TAG = RUNTIME_CONTEXT_TAG
+    _MAX_RECENT_HISTORY = 50
+    _MAX_HISTORY_TOKENS = 8_000  # hard cap on recent history section size (tokens)
     _RUNTIME_CONTEXT_END = RUNTIME_CONTEXT_END
 
     def __init__(self, workspace: Path, timezone: str | None = None, disabled_skills: list[str] | None = None):
@@ -109,6 +98,9 @@ class ContextBuilder:
         session_summary: SessionSummary | None = None,
         workspace: Path | None = None,
         include_memory: bool = True,
+        include_memory_recent_history: bool = True,
+        session_key: str | None = None,
+        unified_session: bool = False,
     ) -> str:
         """Build the system prompt from identity, bootstrap files, memory, and skills."""
         root = workspace or self.workspace
@@ -146,6 +138,29 @@ class ContextBuilder:
         if skills_summary:
             parts.append(render_template("agent/skills_section.md", skills_summary=skills_summary))
 
+        if include_memory_recent_history:
+            entries = self.memory.read_recent_history_for_prompt(
+                since_cursor=self.memory.get_last_dream_cursor(),
+                session_key=session_key,
+                unified_session=unified_session,
+            )
+            if entries:
+                capped = entries[-self._MAX_RECENT_HISTORY:]
+                capped = self._without_duplicate_session_summary(
+                    capped,
+                    session_key=session_key,
+                    session_summary=session_summary,
+                )
+                if capped:
+                    history_text = "\n".join(
+                        f"- [{e['timestamp']}] {e['content']}" for e in capped
+                    )
+                    history_text = truncate_text_to_tokens(
+                        history_text,
+                        self._MAX_HISTORY_TOKENS,
+                    )
+                    parts.append("# Recent History\n\n" + history_text)
+
         if session_summary:
             parts.append(
                 "[Archived Context Summary]\n\n"
@@ -155,6 +170,25 @@ class ContextBuilder:
 
         return "\n\n---\n\n".join(parts)
 
+    @staticmethod
+    def _without_duplicate_session_summary(
+        entries: list[dict[str, Any]],
+        *,
+        session_key: str | None,
+        session_summary: SessionSummary | None,
+    ) -> list[dict[str, Any]]:
+        """Drop the history entry already represented by the session summary."""
+        if not session_summary:
+            return entries
+        for index in range(len(entries) - 1, -1, -1):
+            entry = entries[index]
+            if (
+                entry.get("session_key") == session_key
+                and entry.get("content") == session_summary["text"]
+            ):
+                return [*entries[:index], *entries[index + 1:]]
+        return entries
+
     def _get_identity(self, channel: str | None = None, workspace: Path | None = None) -> str:
         """Get the core identity section."""
         root = workspace or self.workspace
@@ -235,7 +269,7 @@ class ContextBuilder:
     def build_messages(
         self,
         history: list[dict[str, Any]],
-        current_message: str | None,
+        current_message: str,
         *,
         media: list[str] | None = None,
         channel: str | None = None,
@@ -244,70 +278,46 @@ class ContextBuilder:
         runtime_context_blocks: Sequence[RuntimeContextBlock] | None = None,
         workspace: Path | None = None,
         include_memory: bool = True,
+        include_memory_recent_history: bool = True,
+        session_key: str | None = None,
+        unified_session: bool = False,
     ) -> list[dict[str, Any]]:
-        """Compatibility wrapper for callers that need merged adjacent roles."""
-        messages = self.build_transcript(
-            TranscriptInput(
-                history=history,
-                current_message=current_message,
-                media=media,
-                current_role=current_role,
-                session_summary=session_summary,
-                runtime_context_blocks=runtime_context_blocks,
-            ),
-            channel=channel,
-            workspace=workspace,
-            include_memory=include_memory,
-        )
-        if current_message is None:
-            return messages
-        current = messages[-1]
-        if len(messages) < 2 or messages[-2].get("role") != current.get("role"):
-            return messages
-
-        merged = dict(messages[-2])
-        merged["content"] = self._merge_message_content(
-            merged.get("content"),
-            current.get("content"),
-        )
-        current_meta = current.get("_meta")
-        if current.get("role") == "user" and isinstance(current_meta, dict):
-            internal_meta = dict(merged.get("_meta") or {})
-            internal_meta.update(cast(dict[str, Any], current_meta))
-            merged["_meta"] = internal_meta
-        return [*messages[:-2], merged]
-
-    def build_transcript(
-        self,
-        transcript: TranscriptInput,
-        *,
-        channel: str | None = None,
-        workspace: Path | None = None,
-        include_memory: bool = True,
-    ) -> list[dict[str, Any]]:
-        """Build a model transcript while preserving the fresh-turn boundary."""
+        """Build the complete message list for an LLM call."""
         root = workspace or self.workspace
         messages: list[dict[str, Any]] = [
             {
                 "role": "system",
                 "content": self.build_system_prompt(
                     channel=channel,
-                    session_summary=transcript.session_summary,
+                    session_summary=session_summary,
                     workspace=root,
                     include_memory=include_memory,
+                    include_memory_recent_history=include_memory_recent_history,
+                    session_key=session_key,
+                    unified_session=unified_session,
                 ),
             },
-            *transcript.history,
+            *history,
         ]
-        if transcript.current_message is None:
-            return messages
-
         current = self.build_current_message(
-            transcript.current_message,
-            media=list(transcript.media) if transcript.media else None,
-            current_role=transcript.current_role,
-            runtime_context_blocks=transcript.runtime_context_blocks,
+            current_message,
+            media=media,
+            current_role=current_role,
+            runtime_context_blocks=runtime_context_blocks,
         )
+        if messages[-1].get("role") == current_role:
+            last = dict(messages[-1])
+            last["content"] = self._merge_message_content(
+                last.get("content"),
+                current.get("content"),
+            )
+            current_meta = current.get("_meta")
+            if current_role == "user" and isinstance(current_meta, dict):
+                internal_meta = dict(last.get("_meta") or {})
+                internal_meta.update(cast(dict[str, Any], current_meta))
+                last["_meta"] = internal_meta
+            messages[-1] = last
+            return messages
         messages.append(current)
         return messages
 

nanobot/agent/context_governance.py

@@ -1,43 +1,18 @@
-"""Model-message governance and compaction for agent runner requests.
+"""Model-message governance for agent runner requests.
 
-This module owns model-facing message shaping, request pressure, H/delta
-compaction state, and tool-result content normalization. It may return copied
-messages or persisted-result placeholders, but it must not mutate an existing
-session history list in place.
+This module owns model-facing message shaping and tool-result content normalization.
+It may return copied messages or persisted-result placeholders, but it must not
+mutate an existing session history list in place.
 """
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
-from copy import deepcopy
-from dataclasses import dataclass, replace
-from datetime import datetime
+from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
 from loguru import logger
 
-from nanobot.agent.context import TranscriptInput
-from nanobot.providers.base import (
-    LLMResponse,
-    LLMUsage,
-    ProviderCallContext,
-    ProviderConversationState,
-)
-from nanobot.providers.conversation_state import (
-    ProviderConversationStateController,
-    allows_conversation_message_merge,
-)
-from nanobot.runtime_context import (
-    RUNTIME_CONTEXT_MESSAGE_META,
-    detach_runtime_context,
-    reattach_runtime_context,
-)
-from nanobot.session.history_visibility import is_hidden_history_message
-from nanobot.session.summary import (
-    SUMMARY_CONTINUATION_TEXT,
-    SessionSummaryCheckpoint,
-)
 from nanobot.utils.helpers import (
     estimate_message_tokens,
     estimate_prompt_tokens_chain,
@@ -51,17 +26,13 @@ if TYPE_CHECKING:
     from nanobot.agent.tools.registry import ToolRegistry
     from nanobot.providers.base import LLMProvider
 
-TranscriptBuilder = Callable[[TranscriptInput], list[dict[str, Any]]]
-HistoryConsolidator = Callable[
-    [list[dict[str, Any]], str | None],
-    Awaitable[str | None],
-]
-ProviderCompactionConsolidator = Callable[
-    [ProviderConversationState, list[dict[str, Any]], str | None],
-    Awaitable[str | None],
-]
-
 SNIP_SAFETY_BUFFER = 1024
+MICROCOMPACT_MIN_CHARS = 500
+INFLIGHT_COMPACT_TARGET_RATIO = 0.85
+COMPACTABLE_TOOLS = frozenset({
+    "read_file", "exec", "grep", "find_files",
+    "web_search", "web_fetch", "list_dir", "list_exec_sessions",
+})
 # read_file is the recovery path for persisted results; exempting it prevents persist->read->persist loops.
 TOOL_RESULT_OFFLOAD_EXEMPT_TOOLS = frozenset({"read_file"})
 BACKFILL_CONTENT = "[Tool result unavailable — call was interrupted or lost]"
@@ -70,27 +41,6 @@ PLACEHOLDER_TEXTS = frozenset({
 })
 
 
-class ContextWindowExceededError(RuntimeError):
-    """Raised before a locally fitted request that still exceeds its budget."""
-
-    def __init__(
-        self,
-        *,
-        session_key: str | None,
-        estimated_tokens: int,
-        input_budget: int,
-        source: str,
-    ) -> None:
-        self.session_key = session_key
-        self.estimated_tokens = estimated_tokens
-        self.input_budget = input_budget
-        self.source = source
-        super().__init__(
-            "Model input still exceeds the local context budget after request fitting "
-            f"for {session_key or 'default'}: {estimated_tokens}/{input_budget} via {source}"
-        )
-
-
 def _tool_call_name_is_valid(tool_call: Any) -> bool:
     """Whether a persisted OpenAI-style tool_call carries a usable name.
 
@@ -117,522 +67,27 @@ class ContextGovernanceConfig:
     context_window_tokens: int | None = None
     context_block_limit: int | None = None
     max_tokens: int | None = None
-
-
-@dataclass(slots=True)
-class ContextCompactionState:
-    """Track accepted provider input H separately from the unsent delta."""
-
-    raw_messages: list[dict[str, Any]]
-    accepted_messages: list[dict[str, Any]]
-    raw_accepted_boundary: int
-    active_summary: str | None
-    transcript_input: TranscriptInput
-    transcript_builder: TranscriptBuilder
-    consolidate_history: HistoryConsolidator
-    consolidate_provider_compaction: ProviderCompactionConsolidator | None
-    summary_checkpoint: SessionSummaryCheckpoint | None = None
-
-    @classmethod
-    def from_transcript(
-        cls,
-        transcript_input: TranscriptInput,
-        transcript_builder: TranscriptBuilder,
-        consolidate_history: HistoryConsolidator | None,
-        consolidate_provider_compaction: ProviderCompactionConsolidator | None,
-    ) -> tuple[list[dict[str, Any]], ContextCompactionState | None]:
-        """Build the raw transcript and its initial H/delta boundary."""
-        messages = list(transcript_builder(transcript_input))
-        if consolidate_history is None:
-            return messages, None
-        accepted_history_boundary = 1 + len(transcript_input.history)
-        return messages, cls(
-            raw_messages=messages,
-            accepted_messages=deepcopy(messages[:accepted_history_boundary]),
-            raw_accepted_boundary=accepted_history_boundary,
-            active_summary=(
-                transcript_input.session_summary["text"]
-                if transcript_input.session_summary is not None
-                else None
-            ),
-            transcript_input=transcript_input,
-            transcript_builder=transcript_builder,
-            consolidate_history=consolidate_history,
-            consolidate_provider_compaction=consolidate_provider_compaction,
-        )
-
-    def request_messages(
-        self,
-        raw_messages: list[dict[str, Any]],
-    ) -> list[dict[str, Any]]:
-        return [
-            *deepcopy(self.accepted_messages),
-            *deepcopy(raw_messages[self.raw_accepted_boundary:]),
-        ]
-
-    def delta_after_accepted(
-        self,
-        request_messages: list[dict[str, Any]],
-    ) -> list[dict[str, Any]]:
-        return deepcopy(request_messages[len(self.accepted_messages):])
-
-    def accept_request(
-        self,
-        model_messages: list[dict[str, Any]],
-        *,
-        raw_boundary: int,
-    ) -> None:
-        """Advance H after the provider has received one request."""
-        self.accepted_messages = deepcopy(model_messages)
-        self.raw_accepted_boundary = raw_boundary
-
-
-@dataclass(slots=True)
-class ModelRequestState:
-    """Context state shared by every provider request in one runner turn."""
-
-    config: ContextGovernanceConfig
-    conversation: ProviderConversationStateController
-    usage: LLMUsage | None = None
-    messages: list[dict[str, Any]] | None = None
-    tool_definitions: list[dict[str, Any]] | None = None
-    compaction: ContextCompactionState | None = None
-    provider_compaction_applied: bool = False
+    inflight_start_index: int = 0
 
 
 class ContextGovernor:
-    """Own model-request context while preserving persisted history."""
-
-    @staticmethod
-    def _merge_message_content(left: Any, right: Any) -> str | list[dict[str, Any]]:
-        if isinstance(left, str) and isinstance(right, str):
-            return f"{left}\n\n{right}" if left else right
-
-        def _to_blocks(value: Any) -> list[dict[str, Any]]:
-            if isinstance(value, list):
-                return [
-                    cast(dict[str, Any], item)
-                    if isinstance(item, dict)
-                    else {"type": "text", "text": str(item)}
-                    for item in cast(list[Any], value)
-                ]
-            if value is None:
-                return []
-            return [{"type": "text", "text": str(value)}]
-
-        return _to_blocks(left) + _to_blocks(right)
-
-    @classmethod
-    def _merge_adjacent_user_messages_for_model(
-        cls,
-        messages: list[dict[str, Any]],
-    ) -> list[dict[str, Any]]:
-        """Merge adjacent visible user messages only in the model-facing copy."""
-        prepared: list[dict[str, Any]] = []
-        for source in messages:
-            injection = deepcopy(source)
-            if (
-                prepared
-                and injection.get("role") == "user"
-                and prepared[-1].get("role") == "user"
-                and injection.get("content") != SUMMARY_CONTINUATION_TEXT
-                and prepared[-1].get("content") != SUMMARY_CONTINUATION_TEXT
-                and not is_hidden_history_message(injection)
-                and not is_hidden_history_message(prepared[-1])
-                and allows_conversation_message_merge(injection)
-                and allows_conversation_message_merge(prepared[-1])
-            ):
-                merged = dict(prepared[-1])
-                left_meta = merged.get("_meta")
-                right_meta = injection.get("_meta")
-                left_meta_dict = (
-                    cast(dict[str, Any], left_meta) if isinstance(left_meta, dict) else None
-                )
-                right_meta_dict = (
-                    cast(dict[str, Any], right_meta) if isinstance(right_meta, dict) else None
-                )
-                left_marker = (
-                    left_meta_dict.get(RUNTIME_CONTEXT_MESSAGE_META)
-                    if left_meta_dict is not None
-                    else None
-                )
-                right_marker = (
-                    right_meta_dict.get(RUNTIME_CONTEXT_MESSAGE_META)
-                    if right_meta_dict is not None
-                    else None
-                )
-                left_marker_dict = (
-                    cast(dict[str, Any], left_marker) if isinstance(left_marker, dict) else None
-                )
-                right_marker_dict = (
-                    cast(dict[str, Any], right_marker) if isinstance(right_marker, dict) else None
-                )
-                empty_sources: list[str] = []
-                empty_blocks: list[dict[str, Any]] = []
-                detached_left = (
-                    detach_runtime_context(merged.get("content"), left_marker_dict)
-                    if left_marker_dict is not None
-                    else (merged.get("content"), empty_sources, empty_blocks)
-                )
-                detached_right = (
-                    detach_runtime_context(injection.get("content"), right_marker_dict)
-                    if right_marker_dict is not None
-                    else (injection.get("content"), empty_sources, empty_blocks)
-                )
-                if detached_left is not None and detached_right is not None:
-                    left_content, left_sources, left_blocks = detached_left
-                    right_content, right_sources, right_blocks = detached_right
-                    merged_content = cls._merge_message_content(left_content, right_content)
-                    context_blocks = [*left_blocks, *right_blocks]
-                    if context_blocks:
-                        merged_content, marker = reattach_runtime_context(
-                            merged_content,
-                            [*left_sources, *right_sources],
-                            context_blocks,
-                        )
-                        internal_meta = (
-                            dict(left_meta_dict) if left_meta_dict is not None else {}
-                        )
-                        if right_meta_dict is not None:
-                            for key, value in right_meta_dict.items():
-                                internal_meta.setdefault(key, value)
-                        internal_meta[RUNTIME_CONTEXT_MESSAGE_META] = marker
-                        merged["_meta"] = internal_meta
-                    merged["content"] = merged_content
-                else:
-                    merged["content"] = cls._merge_message_content(
-                        merged.get("content"),
-                        injection.get("content"),
-                    )
-                prepared[-1] = merged
-                continue
-            prepared.append(injection)
-        return prepared
-
-    def prepare_messages_for_model(
-        self,
-        config: ContextGovernanceConfig,
-        messages: list[dict[str, Any]],
-    ) -> list[dict[str, Any]]:
-        """Build the normalized model-facing copy of a raw transcript."""
-        governed = self.prepare_for_model(config, messages)
-        return self._merge_adjacent_user_messages_for_model(governed)
+    """Prepare model-copy messages while preserving persisted history."""
 
     def prepare_for_model(
         self,
         config: ContextGovernanceConfig,
         messages: list[dict[str, Any]],
+        compacted_tool_call_ids: set[str],
     ) -> list[dict[str, Any]]:
         updated = self.strip_placeholder_assistant_messages(messages)
         updated = self.strip_malformed_tool_calls(updated)
         updated = self.drop_orphan_tool_results(updated)
         updated = self.backfill_missing_tool_results(updated)
-        return self.apply_tool_result_budget(config, updated)
-
-    def fit_to_budget(
-        self,
-        config: ContextGovernanceConfig,
-        messages: list[dict[str, Any]],
-        *,
-        tool_definitions: list[dict[str, Any]] | None,
-    ) -> list[dict[str, Any]]:
-        """Fit a model-facing copy while keeping the source transcript intact."""
-        updated = self.snip_history(
-            config,
-            messages,
-            tool_definitions=tool_definitions,
-            force=True,
-        )
+        updated = self.apply_tool_result_budget(config, updated)
+        updated = self.compact_inflight_overflow(config, updated, compacted_tool_call_ids)
+        updated = self.snip_history(config, updated)
         updated = self.drop_orphan_tool_results(updated)
-        updated = self.backfill_missing_tool_results(updated)
-        return self.ensure_request_fits(
-            config,
-            updated,
-            tool_definitions=tool_definitions,
-        )
-
-    def ensure_request_fits(
-        self,
-        config: ContextGovernanceConfig,
-        messages: list[dict[str, Any]],
-        *,
-        tool_definitions: list[dict[str, Any]] | None,
-    ) -> list[dict[str, Any]]:
-        """Validate an exact model request without dropping any messages."""
-        if not config.context_window_tokens:
-            return messages
-        budget = self.input_budget(config)
-        estimated, source = estimate_prompt_tokens_chain(
-            config.provider,
-            config.model,
-            messages,
-            tool_definitions,
-        )
-        if budget > 0 and estimated <= budget:
-            return messages
-        raise ContextWindowExceededError(
-            session_key=config.session_key,
-            estimated_tokens=estimated,
-            input_budget=budget,
-            source=source,
-        )
-
-    def request_pressure(
-        self,
-        config: ContextGovernanceConfig,
-        messages: list[dict[str, Any]],
-        usage: LLMUsage | None,
-        *,
-        usage_matches_messages: bool,
-        tool_definitions: list[dict[str, Any]] | None,
-        request_context_tokens: int | None = None,
-    ) -> tuple[int, str] | None:
-        """Return the authoritative measurement when a request is pressured."""
-        if not config.context_window_tokens:
-            return None
-        budget = self.input_budget(config)
-        if request_context_tokens is not None:
-            measured = request_context_tokens
-            source = "resumed provider state plus pending messages"
-        elif (
-            usage_matches_messages
-            and usage is not None
-            and usage.context_tokens is not None
-        ):
-            measured = usage.context_tokens
-            source = "matching provider usage"
-        else:
-            measured, source = estimate_prompt_tokens_chain(
-                config.provider,
-                config.model,
-                messages,
-                tool_definitions,
-            )
-        if budget > 0 and measured < budget:
-            return None
-        return measured, source
-
-    def fit_request(
-        self,
-        config: ContextGovernanceConfig,
-        messages: list[dict[str, Any]],
-        usage: LLMUsage | None,
-        *,
-        usage_matches_messages: bool,
-        tool_definitions: list[dict[str, Any]] | None,
-        request_context_tokens: int | None = None,
-    ) -> tuple[list[dict[str, Any]], bool]:
-        """Fit the request when its measured or estimated input is pressured."""
-        pressure = self.request_pressure(
-            config,
-            messages,
-            usage,
-            usage_matches_messages=usage_matches_messages,
-            tool_definitions=tool_definitions,
-            request_context_tokens=request_context_tokens,
-        )
-        if pressure is None:
-            return messages, False
-        return self.fit_to_budget(
-            config,
-            messages,
-            tool_definitions=tool_definitions,
-        ), True
-
-    @staticmethod
-    def _summary_transcript(
-        compaction: ContextCompactionState,
-        summary: str,
-    ) -> list[dict[str, Any]]:
-        """Rebuild only the stable system prefix around a replacement summary."""
-        return compaction.transcript_builder(
-            replace(
-                compaction.transcript_input,
-                history=[],
-                current_message=None,
-                media=None,
-                session_summary={
-                    "text": summary,
-                    "last_active": datetime.now().astimezone().isoformat(),
-                },
-                runtime_context_blocks=None,
-            )
-        )
-
-    async def summarize_provider_compaction(
-        self,
-        state: ModelRequestState,
-        response: LLMResponse,
-        *,
-        current_request_boundary: int | None,
-    ) -> None:
-        """Materialize the exact input replaced by provider-native compaction."""
-        compaction = state.compaction
-        if (
-            not response.provider_compaction_applied
-            or response.provider_compaction_state is None
-            or compaction is None
-            or compaction.consolidate_provider_compaction is None
-        ):
-            return
-
-        if response.provider_compaction_scope == "prior_context":
-            accepted_messages = compaction.accepted_messages
-            transcript_boundary = compaction.raw_accepted_boundary
-        elif (
-            response.provider_compaction_scope == "current_request"
-            and state.messages is not None
-            and current_request_boundary is not None
-        ):
-            accepted_messages = state.messages
-            transcript_boundary = current_request_boundary
-        else:
-            logger.warning(
-                "Ignoring provider compaction with missing request-boundary scope for {}",
-                state.config.session_key or "default",
-            )
-            return
-
-        summary = await compaction.consolidate_provider_compaction(
-            response.provider_compaction_state,
-            deepcopy(accepted_messages),
-            compaction.active_summary,
-        )
-        if not summary:
-            return
-        compaction.active_summary = summary
-        compaction.summary_checkpoint = SessionSummaryCheckpoint(
-            summary=summary,
-            transcript_boundary=transcript_boundary,
-        )
-
-    async def _compact_request_history(
-        self,
-        state: ModelRequestState,
-        compaction: ContextCompactionState,
-        messages: list[dict[str, Any]],
-        pressure: tuple[int, str],
-        *,
-        tool_definitions: list[dict[str, Any]] | None,
-    ) -> list[dict[str, Any]]:
-        """Replace accepted history H with a checkpoint while preserving delta."""
-        delta_messages = compaction.delta_after_accepted(messages)
-        consolidation_prefix = self.prepare_messages_for_model(
-            state.config,
-            compaction.accepted_messages,
-        )
-        summary = await compaction.consolidate_history(
-            deepcopy(consolidation_prefix),
-            compaction.active_summary,
-        )
-        if not summary:
-            measured, source = pressure
-            raise ContextWindowExceededError(
-                session_key=state.config.session_key,
-                estimated_tokens=measured,
-                input_budget=self.input_budget(state.config),
-                source=source,
-            )
-
-        compaction.active_summary = summary
-        prepared = self.prepare_messages_for_model(
-            state.config,
-            [
-                *self._summary_transcript(compaction, summary),
-                {"role": "user", "content": SUMMARY_CONTINUATION_TEXT},
-                *delta_messages,
-            ],
-        )
-        # Responses-style state is append-only. Replacing H with a
-        # checkpoint requires a fresh request; a successful response may
-        # establish a new provider-owned state at the rewritten boundary.
-        state.conversation.replace_transcript(compaction.raw_messages)
-        state.usage = None
-        prepared = self.ensure_request_fits(
-            state.config,
-            prepared,
-            tool_definitions=tool_definitions,
-        )
-        compaction.summary_checkpoint = SessionSummaryCheckpoint(
-            summary=summary,
-            transcript_boundary=compaction.raw_accepted_boundary,
-        )
-        return prepared
-
-    async def prepare_request(
-        self,
-        state: ModelRequestState,
-        messages: list[dict[str, Any]],
-        *,
-        tool_definitions: list[dict[str, Any]] | None,
-        transcript: list[dict[str, Any]] | None = None,
-    ) -> tuple[list[dict[str, Any]], ProviderCallContext | None]:
-        """Prepare, compact or fit, and record the exact provider payload."""
-        prepared = self.prepare_messages_for_model(state.config, messages)
-        model_messages: list[dict[str, Any]] | None = prepared
-        supplemental_messages: list[dict[str, Any]] | None = None
-        request_context_tokens = None
-        if transcript is not None:
-            if tool_definitions is None:
-                model_messages = None
-                supplemental_messages = [prepared[-1]]
-            request_context_tokens = state.conversation.estimate_request_context_tokens(
-                transcript,
-                model_messages=model_messages,
-                supplemental_messages=supplemental_messages,
-                tool_definitions=tool_definitions,
-            )
-        usage_matches_messages = (
-            state.messages is not None
-            and prepared == state.messages
-            and tool_definitions == state.tool_definitions
-        )
-        request_was_fitted = False
-        compaction = state.compaction
-        if compaction is None:
-            prepared, request_was_fitted = self.fit_request(
-                state.config,
-                prepared,
-                state.usage,
-                usage_matches_messages=usage_matches_messages,
-                tool_definitions=tool_definitions,
-                request_context_tokens=request_context_tokens,
-            )
-        else:
-            pressure = self.request_pressure(
-                state.config,
-                prepared,
-                state.usage,
-                usage_matches_messages=usage_matches_messages,
-                tool_definitions=tool_definitions,
-                request_context_tokens=request_context_tokens,
-            )
-            if pressure is not None:
-                prepared = await self._compact_request_history(
-                    state,
-                    compaction,
-                    messages,
-                    pressure,
-                    tool_definitions=tool_definitions,
-                )
-                model_messages = prepared
-                supplemental_messages = None
-        provider_context = (
-            state.conversation.prepare_request(
-                transcript,
-                context_window_tokens=state.config.context_window_tokens,
-                model_messages=model_messages,
-                supplemental_messages=supplemental_messages,
-                resume_state=not request_was_fitted,
-            )
-            if transcript is not None
-            else state.conversation.independent_request_context(
-                context_window_tokens=state.config.context_window_tokens,
-            )
-        )
-        state.messages = deepcopy(prepared)
-        state.tool_definitions = deepcopy(tool_definitions)
-        return prepared, provider_context
+        return self.backfill_missing_tool_results(updated)
 
     @staticmethod
     def input_budget(config: ContextGovernanceConfig) -> int:
@@ -871,13 +326,71 @@ class ContextGovernor:
                 updated[idx]["content"] = normalized
         return updated
 
+    def compact_inflight_overflow(
+        self,
+        config: ContextGovernanceConfig,
+        messages: list[dict[str, Any]],
+        compacted_tool_call_ids: set[str],
+    ) -> list[dict[str, Any]]:
+        """Compact in-flight tool results only when the request would overflow."""
+        budget = self.input_budget(config)
+        if budget <= 0:
+            return messages
+
+        tools = config.tools.get_definitions()
+        updated = self._apply_recorded_compactions(messages, compacted_tool_call_ids)
+        estimate, source = estimate_prompt_tokens_chain(
+            config.provider,
+            config.model,
+            updated,
+            tools,
+        )
+        if estimate <= budget:
+            return updated
+
+        target = int(budget * INFLIGHT_COMPACT_TARGET_RATIO)
+        candidates = self._inflight_compaction_candidates(
+            config,
+            updated,
+            compacted_tool_call_ids,
+        )
+        if not candidates:
+            return updated
+
+        for candidate_idx, (idx, tool_call_id) in enumerate(candidates):
+            is_newest_candidate = candidate_idx == len(candidates) - 1
+            if is_newest_candidate and estimate <= budget:
+                break
+            if tool_call_id in compacted_tool_call_ids:
+                continue
+            if updated is messages:
+                updated = [dict(m) for m in messages]
+            compacted_tool_call_ids.add(tool_call_id)
+            self._compact_tool_result_at(updated, idx)
+            estimate, source = estimate_prompt_tokens_chain(
+                config.provider,
+                config.model,
+                updated,
+                tools,
+            )
+            if estimate <= target:
+                break
+
+        logger.debug(
+            "In-flight context compaction for {}: prompt={} budget={} target={} via {}, ids={}",
+            config.session_key or "default",
+            estimate,
+            budget,
+            target,
+            source,
+            len(compacted_tool_call_ids),
+        )
+        return updated
+
     def snip_history(
         self,
         config: ContextGovernanceConfig,
         messages: list[dict[str, Any]],
-        *,
-        tool_definitions: list[dict[str, Any]] | None,
-        force: bool = False,
     ) -> list[dict[str, Any]]:
         if not messages or not config.context_window_tokens:
             return messages
@@ -886,15 +399,15 @@ class ContextGovernor:
         if budget <= 0:
             return messages
 
-        if not force:
-            estimate, _ = estimate_prompt_tokens_chain(
-                config.provider,
-                config.model,
-                messages,
-                tool_definitions,
-            )
-            if estimate <= budget:
-                return messages
+        tools = config.tools.get_definitions()
+        estimate, _ = estimate_prompt_tokens_chain(
+            config.provider,
+            config.model,
+            messages,
+            tools,
+        )
+        if estimate <= budget:
+            return messages
 
         system_messages = [dict(msg) for msg in messages if msg.get("role") == "system"]
         non_system = [dict(msg) for msg in messages if msg.get("role") != "system"]
@@ -906,7 +419,7 @@ class ContextGovernor:
             config.provider,
             config.model,
             system_messages,
-            tool_definitions,
+            tools,
         )
         remaining_budget = max(0, budget - max(system_tokens, fixed_tokens))
         kept: list[dict[str, Any]] = []
@@ -921,6 +434,16 @@ class ContextGovernor:
 
         return system_messages + self._legal_history_tail(kept, non_system)
 
+    @staticmethod
+    def _tool_result_compaction_message(message: dict[str, Any]) -> str:
+        name = message.get("name", "tool")
+        return (
+            f"Error: The previous {name} result was compacted to fit context because it was too "
+            "large. Do not repeat the same call unchanged. Retry with a narrower path, query, "
+            "range, or result limit, use another tool, or tell the user the task cannot fit in "
+            "the available context."
+        )
+
     def _legal_history_tail(
         self,
         kept: list[dict[str, Any]],
@@ -939,3 +462,50 @@ class ContextGovernor:
             if messages[idx].get("role") == "user":
                 return messages[idx:]
         return []
+
+    def _apply_recorded_compactions(
+        self,
+        messages: list[dict[str, Any]],
+        compacted_tool_call_ids: set[str],
+    ) -> list[dict[str, Any]]:
+        if not compacted_tool_call_ids:
+            return messages
+        updated = messages
+        for idx, msg in enumerate(messages):
+            if msg.get("role") != "tool":
+                continue
+            tool_call_id = msg.get("tool_call_id")
+            if not tool_call_id or str(tool_call_id) not in compacted_tool_call_ids:
+                continue
+            compaction_message = self._tool_result_compaction_message(msg)
+            if msg.get("content") == compaction_message:
+                continue
+            if updated is messages:
+                updated = [dict(m) for m in messages]
+            updated[idx]["content"] = compaction_message
+        return updated
+
+    def _inflight_compaction_candidates(
+        self,
+        config: ContextGovernanceConfig,
+        messages: list[dict[str, Any]],
+        compacted_tool_call_ids: set[str],
+    ) -> list[tuple[int, str]]:
+        compactable: list[tuple[int, str]] = []
+        for idx, msg in enumerate(messages):
+            if idx < config.inflight_start_index:
+                continue
+            if msg.get("role") != "tool" or msg.get("name") not in COMPACTABLE_TOOLS:
+                continue
+            tool_call_id = msg.get("tool_call_id")
+            if not tool_call_id or str(tool_call_id) in compacted_tool_call_ids:
+                continue
+            content = msg.get("content")
+            if not isinstance(content, str) or len(content) < MICROCOMPACT_MIN_CHARS:
+                continue
+            compactable.append((idx, str(tool_call_id)))
+
+        return compactable
+
+    def _compact_tool_result_at(self, messages: list[dict[str, Any]], idx: int) -> None:
+        messages[idx]["content"] = self._tool_result_compaction_message(messages[idx])

nanobot/agent/loop.py

@@ -13,9 +13,7 @@ import weakref
 from collections.abc import Coroutine, Iterable, Mapping
 from contextlib import AbstractContextManager, ExitStack, nullcontext, suppress
 from dataclasses import dataclass, field
-from datetime import datetime
 from enum import Enum, auto
-from functools import partial
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Awaitable, Callable, TypeVar, cast
 
@@ -25,7 +23,7 @@ from nanobot.agent import context as agent_context
 from nanobot.agent import model_presets as preset_helpers
 from nanobot.agent.autocompact import AutoCompact
 from nanobot.agent.automation_turns import publish_next_deferred_turn
-from nanobot.agent.context import ContextBuilder, PersistedPromptContextResolver, TranscriptInput
+from nanobot.agent.context import ContextBuilder, PersistedPromptContextResolver
 from nanobot.agent.cron_turns import CronTurnCoordinator
 from nanobot.agent.hook import AgentHook, AgentTurnHookFactory
 from nanobot.agent.memory import Consolidator
@@ -40,9 +38,10 @@ from nanobot.agent.subagent import SubagentManager
 from nanobot.agent.tools.context import RequestContext, bind_request_context, reset_request_context
 from nanobot.agent.tools.exec_session import ExecSessionManager
 from nanobot.agent.tools.file_state import FileStateStore, bind_file_states, reset_file_states
-from nanobot.agent.tools.message import capture_message_deliveries
+from nanobot.agent.tools.message import MessageTool
 from nanobot.agent.tools.registry import ToolRegistry
 from nanobot.agent.tools.runtime_control import AgentRuntimeControl
+from nanobot.agent.tools.self import MyTool
 from nanobot.agent.turn_delivery import (
     TurnDelivery,
     TurnDeliveryFactory,
@@ -94,11 +93,7 @@ from nanobot.session.recovery import (
     restore_pending_interruption,
     restore_runtime_checkpoint,
 )
-from nanobot.session.summary import (
-    SUMMARY_CONTINUATION_TEXT,
-    SessionSummary,
-    SessionSummaryCheckpoint,
-)
+from nanobot.session.summary import SessionSummary
 from nanobot.triggers.local_turns import LocalTriggerTurnCoordinator
 from nanobot.utils.cancellation import task_is_cancelling
 from nanobot.utils.document import reference_non_image_attachments
@@ -141,7 +136,7 @@ class TurnContext:
     session: Session | None = None
 
     history: list[dict[str, Any]] = field(default_factory=list)
-    transcript_input: TranscriptInput | None = None
+    initial_messages: list[dict[str, Any]] = field(default_factory=list)
     provider_state: ProviderConversationState | None = field(default=None, repr=False)
     request_context: RequestContext | None = None
     runtime_context_blocks: list[RuntimeContextBlock] = field(default_factory=list)
@@ -150,6 +145,7 @@ class TurnContext:
     final_content: str | None = None
     all_messages: list[dict[str, Any]] = field(default_factory=list)
     stop_reason: str = ""
+    had_injections: bool = False
     streamed_content: bool = False
 
     input_persisted_early: bool = False
@@ -166,8 +162,6 @@ class TurnContext:
 
     pending_queue: asyncio.Queue[InboundMessage] | None = None
     pending_summary: SessionSummary | None = None
-    summary_checkpoint: SessionSummaryCheckpoint | None = None
-    provider_compaction_applied: bool = False
 
     ephemeral: bool = False
     run_extra_hooks_for_ephemeral: bool = False
@@ -281,6 +275,7 @@ class AgentLoop:
         channels_config: ChannelsConfig | None = None,
         timezone: str | None = None,
         session_ttl_minutes: int = 0,
+        consolidation_ratio: float = 0.5,
         hooks: list[AgentHook] | None = None,
         hook_factories: list[AgentTurnHookFactory] | None = None,
         unified_session: bool = False,
@@ -437,8 +432,8 @@ class AgentLoop:
             ("cron", self._cron_turns),
             ("local trigger", self._local_trigger_turns),
         )
-        # NANOBOT_MAX_CONCURRENT_REQUESTS: unset or <=0 means unlimited.
-        _max = int(os.environ.get("NANOBOT_MAX_CONCURRENT_REQUESTS", "0"))
+        # NANOBOT_MAX_CONCURRENT_REQUESTS: <=0 means unlimited; default 3.
+        _max = int(os.environ.get("NANOBOT_MAX_CONCURRENT_REQUESTS", "3"))
         self._concurrency_gate: asyncio.Semaphore | None = (
             asyncio.Semaphore(_max) if _max > 0 else None
         )
@@ -451,6 +446,8 @@ class AgentLoop:
                 workspace_scopes=self.workspace_scopes,
                 unified_session=unified_session,
             ),
+            consolidation_ratio=consolidation_ratio,
+            unified_session=unified_session,
         )
         self.auto_compact = AutoCompact(
             sessions=self.sessions,
@@ -522,6 +519,7 @@ class AgentLoop:
             disabled_skills=defaults.disabled_skills,
             session_ttl_minutes=defaults.session_ttl_minutes,
             idle_compact_check_interval_seconds=defaults.idle_compact_check_interval_seconds,
+            consolidation_ratio=defaults.consolidation_ratio,
             tools_config=config.tools,
             model_presets=preset_helpers.configured_model_presets(config),
             model_preset=defaults.model_preset,
@@ -646,11 +644,20 @@ class AgentLoop:
             timezone=self.context.timezone or "UTC",
             workspace_sandbox=self.workspace_scopes.sandbox_status,
             runtime_events=self.runtime_events,
-            runtime_control=AgentRuntimeControl(self),
         )
         loader = ToolLoader()
         registered = loader.load(ctx, self.tools)
 
+        # MyTool receives only the explicit runtime-control capability.
+        if self.tools_config.my.enable:
+            self.tools.register(
+                MyTool(
+                    runtime_control=AgentRuntimeControl(self),
+                    modify_allowed=self.tools_config.my.allow_set,
+                )
+            )
+            registered.append("my")
+
         logger.info("Registered {} tools: {}", len(registered), registered)
 
     def register_runtime_context_provider(
@@ -730,15 +737,22 @@ class AgentLoop:
             return True
         return False
 
-    def _build_transcript_input(self, ctx: TurnContext) -> TranscriptInput:
-        """Capture the persisted history and fresh input as separate transcript parts."""
+    def _build_initial_messages(self, ctx: TurnContext) -> list[dict[str, Any]]:
+        """Build the initial message list for the LLM turn."""
         assert ctx.session is not None
-        return TranscriptInput(
+        scope = self.workspace_scopes.for_message(ctx.msg, ctx.session.metadata)
+        return self.context.build_messages(
             history=ctx.history,
             current_message=ctx.msg.content,
             media=ctx.msg.media if ctx.kind is TurnKind.USER and ctx.msg.media else None,
+            channel=ctx.delivery.route.channel,
             session_summary=ctx.pending_summary,
+            workspace=scope.project_path,
             runtime_context_blocks=ctx.runtime_context_blocks,
+            include_memory=ctx.session.policy.persist,
+            include_memory_recent_history=not ctx.ephemeral,
+            session_key=ctx.session.key,
+            unified_session=self._unified_session,
         )
 
     def _request_context_for_turn(self, ctx: TurnContext) -> RequestContext:
@@ -859,22 +873,6 @@ class AgentLoop:
             metadata={**metadata, "render_as": "text"},
         )
 
-    def _track_active_task(self, key: str, task: asyncio.Task[Any]) -> None:
-        """Track active session work until its task group becomes empty."""
-        tasks = self._active_tasks.setdefault(key, set())
-        tasks.add(task)
-        task.add_done_callback(partial(self._active_task_done, key, tasks))
-
-    def _active_task_done(
-        self,
-        key: str,
-        tasks: set[asyncio.Task[Any]],
-        task: asyncio.Task[Any],
-    ) -> None:
-        tasks.discard(task)
-        if not tasks and self._active_tasks.get(key) is tasks:
-            self._active_tasks.pop(key, None)
-
     async def _cancel_active_tasks(self, key: str) -> int:
         """Cancel and await all active work for *key*.
 
@@ -930,9 +928,22 @@ class AgentLoop:
             return
         remember_last_channel(session.metadata, msg.channel, msg.chat_id)
 
+    @staticmethod
+    def _replay_token_budget(runtime: LLMRuntime) -> int:
+        """Derive a token budget for session history replay from the context window."""
+        if runtime.context_window_tokens <= 0:
+            return 0
+        max_output = runtime.generation.max_tokens
+        try:
+            reserved_output = int(max_output)
+        except (TypeError, ValueError):
+            reserved_output = 4096
+        budget = runtime.context_window_tokens - max(1, reserved_output) - 1024
+        return budget if budget > 0 else max(128, runtime.context_window_tokens // 2)
+
     async def _run_agent_loop(
         self,
-        transcript_input: TranscriptInput,
+        initial_messages: list[dict[str, Any]],
         on_progress: Callable[..., Awaitable[None]] | None = None,
         on_stream: Callable[[str], Awaitable[None]] | None = None,
         on_stream_end: Callable[..., Awaitable[None]] | None = None,
@@ -1113,12 +1124,6 @@ class AgentLoop:
             message_metadata=request_metadata,
             session_metadata=session.metadata if session is not None else None,
         )
-        transcript_builder = partial(
-            self.context.build_transcript,
-            channel=request_ctx.channel,
-            workspace=effective_scope.project_path,
-            include_memory=session.policy.persist if session is not None else True,
-        )
         if request_context is None:
             request_ctx = dataclasses.replace(
                 request_ctx,
@@ -1165,13 +1170,11 @@ class AgentLoop:
                 run_extra_hooks_for_ephemeral=run_extra_hooks_for_ephemeral,
             ))
             result = await self.runner.run(AgentRunSpec(
-                initial_messages=None,
+                initial_messages=initial_messages,
                 tools=effective_tools,
                 runtime=runtime,
                 max_iterations=self.max_iterations,
                 max_tool_result_chars=self.max_tool_result_chars,
-                transcript_input=transcript_input,
-                transcript_builder=transcript_builder,
                 hook=hook,
                 concurrent_tools=True,
                 workspace=effective_scope.project_path,
@@ -1180,26 +1183,6 @@ class AgentLoop:
                 provider_retry_mode=self.provider_retry_mode,
                 retry_wait_callback=on_retry_wait,
                 checkpoint_callback=_checkpoint,
-                consolidate_history=(
-                    partial(
-                        self.consolidator.summarize_transcript,
-                        runtime=runtime,
-                        session_key=session.key,
-                        tools=effective_tools.get_definitions(),
-                    )
-                    if session is not None and not ephemeral
-                    else None
-                ),
-                consolidate_provider_compaction=(
-                    partial(
-                        self.consolidator.summarize_provider_compaction,
-                        runtime=runtime,
-                        session_key=session.key,
-                        tools=effective_tools.get_definitions(),
-                    )
-                    if session is not None and not ephemeral
-                    else None
-                ),
                 injection_callback=_drain_pending,
                 terminal_injection_callback=_wait_for_pending,
                 # Sustained goals may legitimately exceed NANOBOT_LLM_TIMEOUT_S; idle stall
@@ -1380,7 +1363,12 @@ class AgentLoop:
                 # Compute the effective session key before dispatching
                 # This ensures /stop command can find tasks correctly when unified session is enabled
                 task = asyncio.create_task(self._dispatch(msg))
-                self._track_active_task(effective_key, task)
+                active_tasks: set[asyncio.Task[Any]] = self._active_tasks.setdefault(
+                    effective_key,
+                    set(),
+                )
+                active_tasks.add(task)
+                task.add_done_callback(active_tasks.discard)
         finally:
             await self.aclose()
 
@@ -1745,12 +1733,18 @@ class AgentLoop:
         msg: InboundMessage,
         final_content: str,
         stop_reason: str,
+        had_injections: bool,
         streamed_content: bool,
         *,
         log_content: bool = True,
         turn_latency_ms: int | None = None,
     ) -> OutboundMessage | None:
         """Assemble the final outbound message from turn results."""
+        # MessageTool suppression
+        if (mt := self.tools.get("message")) and isinstance(mt, MessageTool) and mt._sent_in_turn:
+            if not had_injections or stop_reason == "empty_final_response":
+                return None
+
         if log_content:
             preview = final_content[:120] + "..." if len(final_content) > 120 else final_content
             logger.info("Response to {}:{}: {}", msg.channel, msg.sender_id, preview)
@@ -1900,14 +1894,21 @@ class AgentLoop:
         if ctx.on_runtime_admitted is not None:
             await ctx.on_runtime_admitted(runtime)
         if not ctx.ephemeral:
-            ctx.session, ctx.pending_summary = self.auto_compact.prepare_session(
+            await self.consolidator.maybe_consolidate_by_tokens(
                 session,
-                ctx.session_key,
+                runtime=runtime,
             )
-            session = ctx.require_session()
         is_subagent = ctx.kind is TurnKind.SYSTEM and ctx.msg.sender_id == "subagent"
 
-        ctx.history = session.get_history(extend_to_user=is_subagent)
+        if ctx.kind is TurnKind.USER and (message_tool := self.tools.get("message")):
+            if isinstance(message_tool, MessageTool):
+                message_tool.start_turn()
+
+        _hist_kwargs: dict[str, Any] = {
+            "max_tokens": self._replay_token_budget(runtime),
+            "extend_to_user": is_subagent,
+        }
+        ctx.history = session.get_history(**_hist_kwargs)
         stored_state = session.provider_state
         subagent_followup_persisted = False
         if is_subagent:
@@ -1991,7 +1992,7 @@ class AgentLoop:
             # Upgrade the replay-safe baseline to the resumable state before
             # prompt assembly and the first model checkpoint.
             self.sessions.save(session)
-        ctx.transcript_input = self._build_transcript_input(ctx)
+        ctx.initial_messages = self._build_initial_messages(ctx)
 
         if ctx.on_progress is None:
             ctx.on_progress = ctx.delivery.progress_callback()
@@ -2003,43 +2004,35 @@ class AgentLoop:
         if ctx.visible_run_started_at is None:
             ctx.visible_run_started_at = time.time()
         await ctx.delivery.running(started_at=ctx.visible_run_started_at)
-        assert ctx.transcript_input is not None
-        with capture_message_deliveries() as message_sends:
-            result = await self._run_agent_loop(
-                ctx.transcript_input,
-                runtime=runtime,
-                on_progress=ctx.on_progress,
-                on_stream=ctx.on_stream,
-                on_stream_end=ctx.on_stream_end,
-                on_retry_wait=ctx.on_retry_wait,
-                session=ctx.session,
-                pending_queue=ctx.pending_queue,
-                ephemeral=ctx.ephemeral,
-                run_extra_hooks_for_ephemeral=ctx.run_extra_hooks_for_ephemeral,
-                hooks=ctx.hooks,
-                hook_factories=ctx.hook_factories,
-                turn_scopes=ctx.turn_scopes,
-                tools=ctx.tools,
-                request_context=ctx.request_context,
-                provider_state=ctx.provider_state,
-            )
+        result = await self._run_agent_loop(
+            ctx.initial_messages,
+            runtime=runtime,
+            on_progress=ctx.on_progress,
+            on_stream=ctx.on_stream,
+            on_stream_end=ctx.on_stream_end,
+            on_retry_wait=ctx.on_retry_wait,
+            session=ctx.session,
+            pending_queue=ctx.pending_queue,
+            ephemeral=ctx.ephemeral,
+            run_extra_hooks_for_ephemeral=ctx.run_extra_hooks_for_ephemeral,
+            hooks=ctx.hooks,
+            hook_factories=ctx.hook_factories,
+            turn_scopes=ctx.turn_scopes,
+            tools=ctx.tools,
+            request_context=ctx.request_context,
+            provider_state=ctx.provider_state,
+        )
         ctx.final_content = result.final_content
         ctx.all_messages = result.messages
-        ctx.summary_checkpoint = result.summary_checkpoint
-        ctx.provider_compaction_applied = result.provider_compaction_applied
         ctx.stop_reason = result.stop_reason
-        if (
-            ctx.kind is TurnKind.USER
-            and (ctx.delivery.route.channel, ctx.delivery.route.chat_id) in message_sends
-            and (not result.had_injections or result.stop_reason == "empty_final_response")
-        ):
-            ctx.suppress_response = True
+        ctx.had_injections = result.had_injections
         ctx.usage = result.usage
         ctx.delivery.record_usage(ctx.usage)
         if ctx.kind is TurnKind.USER:
             await turn_continuation.maybe_continue_turn(ctx)
 
     async def _persist_turn(self, ctx: TurnContext) -> None:
+        runtime = ctx.require_runtime()
         session = ctx.require_session()
         turn_continuation.prepare_save_boundary(ctx)
 
@@ -2065,18 +2058,15 @@ class AgentLoop:
         self._save_turn(
             session, ctx.all_messages, ctx.save_skip,
             turn_latency_ms=ctx.turn_latency_ms,
-            summary_checkpoint=ctx.summary_checkpoint,
-            input_persisted_early=ctx.input_persisted_early,
         )
-        if (
-            not ctx.ephemeral
-            and ctx.provider_compaction_applied
-            and ctx.summary_checkpoint is not None
-        ):
-            # The next request must rebuild from the portable checkpoint;
-            # the opaque continuation predates that transcript rewrite.
-            session.provider_state = None
         ctx.delivery.record_latency(ctx.turn_latency_ms)
+        if not ctx.ephemeral:
+            self.schedule_background(
+                self.consolidator.maybe_consolidate_by_tokens(
+                    session,
+                    runtime=runtime,
+                )
+            )
         self._clear_pending_user_turn(session)
         self._clear_runtime_checkpoint(session)
         self.sessions.save(session)
@@ -2104,6 +2094,7 @@ class AgentLoop:
             ctx.delivery.delivery_message,
             cast(str, ctx.final_content),
             ctx.stop_reason,
+            ctx.had_injections,
             ctx.streamed_content,
             log_content=ctx.require_session().policy.log_content,
             turn_latency_ms=ctx.turn_latency_ms,
@@ -2150,55 +2141,6 @@ class AgentLoop:
 
         return filtered
 
-    @staticmethod
-    def _insert_summary_checkpoint(
-        session: Session,
-        checkpoint: SessionSummaryCheckpoint,
-        *,
-        insert_at: int | None = None,
-    ) -> None:
-        """Commit a replacement summary and its hidden transcript boundary."""
-        hint = {
-            "role": "user",
-            "content": SUMMARY_CONTINUATION_TEXT,
-            HIDDEN_HISTORY_META: True,
-            "timestamp": datetime.now().isoformat(),
-        }
-        if insert_at is None:
-            session.messages.append(hint)
-            checkpoint_session_index = len(session.messages) - 1
-        else:
-            session.messages.insert(insert_at, hint)
-            checkpoint_session_index = insert_at
-        session.metadata["_last_summary"] = {
-            "text": checkpoint.summary,
-            "last_active": session.updated_at.isoformat(),
-        }
-        session.last_archived = checkpoint_session_index
-
-    @staticmethod
-    def _validated_checkpoint_boundary(
-        checkpoint: SessionSummaryCheckpoint | None,
-        *,
-        skip: int,
-        message_count: int,
-        session_key: str,
-    ) -> int | None:
-        """Return a checkpoint boundary only when it belongs to this turn."""
-        if checkpoint is None:
-            return None
-        boundary = checkpoint.transcript_boundary
-        if skip - 1 <= boundary <= message_count:
-            return boundary
-        logger.warning(
-            "Ignoring invalid summary boundary {} outside [{}, {}] for {}",
-            boundary,
-            skip - 1,
-            message_count,
-            session_key,
-        )
-        return None
-
     def _save_turn(
         self,
         session: Session,
@@ -2206,10 +2148,10 @@ class AgentLoop:
         skip: int,
         *,
         turn_latency_ms: int | None = None,
-        summary_checkpoint: SessionSummaryCheckpoint | None = None,
-        input_persisted_early: bool = False,
     ) -> None:
-        """Commit new-turn messages and an optional summary boundary."""
+        """Save new-turn messages into session, truncating large tool results."""
+        from datetime import datetime
+
         declared_tool_call_ids = {
             str(tc["id"])
             for m in session.messages
@@ -2226,30 +2168,8 @@ class AgentLoop:
         }
         last_assistant_idx: int | None = None
         saved_followup_ids: set[str] = set()
-        checkpoint_boundary = self._validated_checkpoint_boundary(
-            summary_checkpoint,
-            skip=skip,
-            message_count=len(messages),
-            session_key=session.key,
-        )
-
-        # The trigger input may already be the session tail while still being
-        # the first message after the replacement checkpoint.
-        if summary_checkpoint is not None and checkpoint_boundary == skip - 1:
-            insert_at = len(session.messages) - (1 if input_persisted_early else 0)
-            self._insert_summary_checkpoint(
-                session,
-                summary_checkpoint,
-                insert_at=insert_at,
-            )
-
-        for message_index, message in enumerate(messages[skip:], start=skip):
-            # Insert against the raw transcript index before filtering the
-            # message so persistence cleanup cannot shift the H/Δ boundary.
-            if summary_checkpoint is not None and checkpoint_boundary == message_index:
-                self._insert_summary_checkpoint(session, summary_checkpoint)
-
-            entry = dict(message)
+        for m in messages[skip:]:
+            entry = dict(m)
             followup_id_value = cast(object, entry.pop(PENDING_FOLLOWUP_ID_KEY, None))
             followup_ids = (
                 [followup_id_value]
@@ -2328,8 +2248,6 @@ class AgentLoop:
                     for tc in (cast(dict[str, Any], tc_value),)
                     if tc.get("id")
                 )
-        if summary_checkpoint is not None and checkpoint_boundary == len(messages):
-            self._insert_summary_checkpoint(session, summary_checkpoint)
         if turn_latency_ms is not None and last_assistant_idx is not None:
             session.messages[last_assistant_idx]["latency_ms"] = int(turn_latency_ms)
         if saved_followup_ids:

nanobot/agent/memory.py

@@ -1,4 +1,4 @@
-"""Memory storage, transcript archiving, and session checkpoint consolidation."""
+"""Memory system: pure file I/O store and lightweight Consolidator."""
 
 # Tool schemas are installed by the ``@tool_parameters`` class decorator at
 # runtime; static analyzers cannot observe that it clears ``parameters`` from
@@ -21,7 +21,6 @@ from typing import TYPE_CHECKING, Any, Callable, Iterator, cast
 from loguru import logger
 
 from nanobot.llm_usage.context import llm_usage_source
-from nanobot.providers.base import ProviderCallContext, ProviderConversationState
 from nanobot.runtime_context import public_history_messages
 from nanobot.session.manager import (
     MIN_COMPACTED_REPLAY_MESSAGES,
@@ -33,10 +32,10 @@ from nanobot.utils.gitstore import GitStore
 from nanobot.utils.helpers import (
     content_with_media_breadcrumbs,
     ensure_dir,
+    estimate_message_tokens,
     estimate_prompt_tokens_chain,
     strip_think,
     truncate_text,
-    truncate_text_to_tokens,
 )
 from nanobot.utils.prompt_templates import render_template
 from nanobot.utils.workspace_prompts import (
@@ -63,6 +62,12 @@ class MemoryStore:
     # Deliberately excludes memory/.dream_cursor so progress bookkeeping never
     # appears as a durable-memory edit in the audit record.
     _DREAM_CONTENT_PATHS = ("SOUL.md", "USER.md", "memory/MEMORY.md")
+    # Per-file cap when embedding current contents into the Dream prompt. The
+    # durable files are tiny in practice (~5 KB total), but a runaway file must
+    # not unbounded the prompt.
+    _DREAM_FILE_EMBED_CAP = 8000
+    _INTERNAL_HISTORY_SESSION_PREFIXES = ("cron:", "dream:")
+    _INTERNAL_HISTORY_SESSION_KEYS = {"heartbeat"}
     _LEGACY_ENTRY_START_RE = re.compile(r"^\[(\d{4}-\d{2}-\d{2}[^\]]*)\]\s*")
     _LEGACY_TIMESTAMP_RE = re.compile(r"^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2})\]\s*")
     _LEGACY_RAW_MESSAGE_RE = re.compile(
@@ -256,29 +261,6 @@ class MemoryStore:
 
     # -- history.jsonl — append-only, JSONL format ---------------------------
 
-    def _normalize_history_entry(
-        self,
-        entry: str,
-        *,
-        max_chars: int | None = None,
-    ) -> str:
-        """Return the exact bounded, model-safe text accepted by the journal."""
-        limit = max_chars if max_chars is not None else _HISTORY_ENTRY_HARD_CAP
-        raw = entry.rstrip()
-        content = strip_think(raw)
-        if len(content) > limit:
-            if not self._oversize_logged:
-                self._oversize_logged = True
-                logger.warning(
-                    "history entry exceeds {} chars ({}); truncating. "
-                    "Usually means a caller forgot its own cap; "
-                    "further occurrences suppressed.",
-                    limit,
-                    len(content),
-                )
-            content = truncate_text(content, limit)
-        return content
-
     def append_history(
         self,
         entry: str,
@@ -293,16 +275,27 @@ class MemoryStore:
         persisted. If the cleaned content is empty but the raw entry wasn't,
         the record is persisted with an empty string rather than falling back
         to the raw leak — otherwise `strip_think`'s guarantees would be
-        undone when Dream consumes the journal entry.
+        undone by history replay / consolidation downstream.
 
         A defensive cap (*max_chars*, default ``_HISTORY_ENTRY_HARD_CAP``) is
         applied as a final safety net: individual callers should cap their own
         content more tightly; this default only exists to catch unintentional
         large writes (e.g. an LLM echoing its input back as a "summary").
         """
+        limit = max_chars if max_chars is not None else _HISTORY_ENTRY_HARD_CAP
         ts = datetime.now().strftime("%Y-%m-%d %H:%M")
         raw = entry.rstrip()
-        content = self._normalize_history_entry(entry, max_chars=max_chars)
+        if len(raw) > limit:
+            if not self._oversize_logged:
+                self._oversize_logged = True
+                logger.warning(
+                    "history entry exceeds {} chars ({}); truncating. "
+                    "Usually means a caller forgot its own cap; "
+                    "further occurrences suppressed.",
+                    limit, len(raw),
+                )
+            raw = truncate_text(raw, limit)
+        content = strip_think(raw)
         # Cursor allocation and the append must be atomic: concurrent writers
         # could otherwise read the same current cursor and emit duplicates.
         with self._append_lock:
@@ -310,7 +303,7 @@ class MemoryStore:
             if raw and not content:
                 logger.debug(
                     "history entry {} stripped to empty (likely template leak); "
-                    "persisting empty content to avoid re-polluting Dream input",
+                    "persisting empty content to avoid re-polluting context",
                     cursor,
                 )
             record = {"cursor": cursor, "timestamp": ts, "content": content}
@@ -400,6 +393,36 @@ class MemoryStore:
         """Return history entries with a valid cursor > *since_cursor*."""
         return [e for e, c in self._iter_valid_entries() if c > since_cursor]
 
+    @classmethod
+    def _is_internal_history_session(cls, session_key: str | None) -> bool:
+        if not session_key:
+            return False
+        return (
+            session_key in cls._INTERNAL_HISTORY_SESSION_KEYS
+            or session_key.startswith(cls._INTERNAL_HISTORY_SESSION_PREFIXES)
+        )
+
+    def read_recent_history_for_prompt(
+        self,
+        since_cursor: int,
+        *,
+        session_key: str | None,
+        unified_session: bool = False,
+    ) -> list[dict[str, Any]]:
+        """Return unprocessed history entries safe to inject into a turn prompt."""
+        entries = self.read_unprocessed_history(since_cursor=since_cursor)
+        if session_key is None:
+            return entries
+        if not unified_session:
+            return [e for e in entries if e.get("session_key") == session_key]
+
+        return [
+            entry
+            for entry in entries
+            if (entry_session := entry.get("session_key")) == session_key
+            or not self._is_internal_history_session(entry_session)
+        ]
+
     def compact_history(self) -> None:
         """Drop oldest processed entries without discarding pending Dream input."""
         if self.max_history_entries <= 0:
@@ -546,7 +569,9 @@ class MemoryStore:
         Returns ``(prompt, last_cursor)`` or ``None`` if nothing to process.
 
         The current contents of the durable memory files (SOUL.md, USER.md,
-        memory/MEMORY.md) reach Dream through the normal agent system context.
+        memory/MEMORY.md) are embedded so the model edits the real files rather
+        than a stale mental model — eliminating a class of failed/out-of-bounds
+        edits that previously produced hallucinated audit records.
         """
         last_cursor = self.get_last_dream_cursor()
         entries = self.read_unprocessed_history(since_cursor=last_cursor)
@@ -559,9 +584,35 @@ class MemoryStore:
             for e in batch
         )
         template = self._dream_template()
-        prompt = f"{template}\n\n## Conversation History\n{history_text}"
+        files_section = self._render_current_memory_files()
+        prompt = (
+            f"{template}\n\n{files_section}\n\n"
+            f"## Conversation History\n{history_text}"
+        )
         return (prompt, batch[-1]["cursor"])
 
+    def _render_current_memory_files(self) -> str:
+        """Render the durable memory files' current contents for the Dream prompt.
+
+        Missing files render as ``(empty)``; oversized files are capped. The
+        section is the ground truth the model must edit against.
+        """
+        files = [
+            ("SOUL.md", self.soul_file),
+            ("USER.md", self.user_file),
+            ("memory/MEMORY.md", self.memory_file),
+        ]
+        blocks: list[str] = []
+        for label, path in files:
+            try:
+                content = path.read_text(encoding="utf-8") if path.exists() else ""
+            except OSError:
+                content = ""
+            if len(content) > self._DREAM_FILE_EMBED_CAP:
+                content = truncate_text(content, self._DREAM_FILE_EMBED_CAP) + "\n...[truncated]"
+            blocks.append(f"### {label}\n{content}" if content.strip() else f"### {label}\n(empty)")
+        return "## Current Memory Files\n" + "\n\n".join(blocks)
+
     def dream_content_diff(self) -> str:
         """Structured summary of uncommitted changes to the durable memory files.
 
@@ -668,28 +719,21 @@ class MemoryStore:
         *,
         max_chars: int | None = None,
         session_key: str | None = None,
-    ) -> str:
-        """Persist and return a bounded raw checkpoint when summarization degrades."""
-        checkpoint = self._build_raw_checkpoint(messages, max_chars=max_chars)
-        self.append_history(checkpoint, session_key=session_key)
+    ) -> None:
+        """Fallback: dump raw messages to history.jsonl without LLM summarization."""
+        limit = max_chars if max_chars is not None else _RAW_ARCHIVE_MAX_CHARS
+        formatted = truncate_text(
+            self._format_messages(public_history_messages(messages)),
+            limit,
+        )
+        self.append_history(
+            f"[RAW] {len(messages)} messages\n"
+            f"{formatted}",
+            session_key=session_key,
+        )
         logger.warning(
             "Memory consolidation degraded: raw-archived {} messages", len(messages)
         )
-        return checkpoint
-
-    def _build_raw_checkpoint(
-        self,
-        messages: list[dict[str, Any]],
-        *,
-        max_chars: int | None = None,
-    ) -> str:
-        """Build the same bounded checkpoint as :meth:`raw_archive` without writing it."""
-        limit = max_chars if max_chars is not None else _RAW_ARCHIVE_MAX_CHARS
-        checkpoint = (
-            f"[RAW] {len(messages)} messages\n"
-            f"{self._format_messages(public_history_messages(messages))}"
-        )
-        return self._normalize_history_entry(checkpoint, max_chars=limit)
 
     # ------------------------------------------------------------------
     # Dream helpers
@@ -741,275 +785,21 @@ class MemoryStore:
 
 
 # ---------------------------------------------------------------------------
-# Memory ingestion and context-pressure coordination
+# Consolidator — lightweight token-budget triggered consolidation
 # ---------------------------------------------------------------------------
 
-# Raw fallbacks use a tighter cap. Completed model summaries may scale with the
-# configured generation budget, while append_history() still enforces the
-# emergency hard cap against pathological provider output.
-_RAW_ARCHIVE_MAX_CHARS = 16_000   # fallback dump (LLM failed)
-_HISTORY_ENTRY_HARD_CAP = 64_000  # emergency cap in append_history
-
-
-class MemoryArchiver:
-    """Write durable transcript batches to the Memory ingestion journal.
-
-    The archiver deliberately has no SessionManager dependency: it may read a
-    captured transcript batch and append to history.jsonl, but it cannot mutate
-    provider continuation state or advance a session watermark.
-    """
-
-    def __init__(
-        self,
-        store: MemoryStore,
-        build_messages: Callable[..., list[dict[str, Any]]],
-        get_tool_definitions: Callable[[], list[dict[str, Any]]],
-        resolve_prompt_context: Callable[[Session], tuple[str | None, Path | None]] | None = None,
-    ) -> None:
-        self.store = store
-        self._build_messages = build_messages
-        self._get_tool_definitions = get_tool_definitions
-        self._resolve_prompt_context = resolve_prompt_context
-
-    def _raw_checkpoint(
-        self,
-        messages: list[dict[str, Any]],
-        *,
-        session_key: str,
-        previous_summary: str | None,
-        max_tokens: int,
-    ) -> str:
-        """Persist the failed chunk and return a bounded replacement checkpoint."""
-        raw = self.store.raw_archive(messages, session_key=session_key)
-        return self._combine_raw_checkpoint(
-            raw,
-            previous_summary=previous_summary,
-            max_tokens=max_tokens,
-        )
-
-    @staticmethod
-    def _combine_raw_checkpoint(
-        raw: str,
-        *,
-        previous_summary: str | None,
-        max_tokens: int,
-    ) -> str:
-        """Return a bounded checkpoint that preserves prior and newly archived context."""
-        token_limit = max(1, max_tokens)
-        if not previous_summary:
-            return truncate_text_to_tokens(raw, token_limit)
-
-        combined = (
-            "[Previous archived context]\n"
-            f"{previous_summary}\n\n"
-            "[Newly archived raw context]\n"
-            f"{raw}"
-        )
-        bounded = truncate_text_to_tokens(combined, token_limit)
-        if bounded == combined:
-            return combined
-
-        # Keep evidence from both sides when their full concatenation cannot fit.
-        section_limit = max(1, (token_limit - 32) // 2)
-        return truncate_text_to_tokens(
-            "[Previous archived context]\n"
-            f"{truncate_text_to_tokens(previous_summary, section_limit)}\n\n"
-            "[Newly archived raw context]\n"
-            f"{truncate_text_to_tokens(raw, section_limit)}",
-            token_limit,
-        )
-
-    async def archive(
-        self,
-        source_messages: list[dict[str, Any]],
-        *,
-        runtime: LLMRuntime,
-        session_key: str,
-        history: list[dict[str, Any]],
-        request_tools: list[dict[str, Any]],
-        previous_summary: str | None = None,
-        input_token_budget: int | None = None,
-        fallback_max_tokens: int | None = None,
-        provider_state: ProviderConversationState | None = None,
-    ) -> str | None:
-        """Append the archive prompt to H and persist its summary."""
-        if not source_messages:
-            return None
-
-        def raw_fallback() -> str:
-            return self._raw_checkpoint(
-                source_messages,
-                session_key=session_key,
-                previous_summary=previous_summary,
-                max_tokens=(
-                    fallback_max_tokens
-                    if fallback_max_tokens is not None
-                    else runtime.generation.max_tokens
-                ),
-            )
-
-        prompt = render_template(
-            "agent/consolidator_archive.md",
-            strip=True,
-            archive_count=len(source_messages),
-        )
-        prompt_message = {"role": "user", "content": prompt}
-        provider_context = None
-        call_tools = request_tools
-        if provider_state is not None:
-            if not runtime.provider.can_resume_conversation_state(
-                provider_state,
-                runtime.model,
-            ):
-                return raw_fallback()
-            instruction_messages: list[dict[str, Any]] = []
-            for message in history:
-                if message.get("role") not in {"system", "developer"}:
-                    break
-                instruction_messages.append(dict(message))
-            request_messages = [*instruction_messages, prompt_message]
-            provider_context = ProviderCallContext(
-                conversation_state=provider_state.with_pending_messages([
-                    *provider_state.pending_messages,
-                    prompt_message,
-                ]),
-                context_window_tokens=runtime.context_window_tokens,
-                session_id=session_key,
-            )
-            call_tools = []
-        else:
-            request_messages = [
-                *[dict(message) for message in history],
-                prompt_message,
-            ]
-        if input_token_budget is not None and provider_context is None:
-            estimated, source = estimate_prompt_tokens_chain(
-                runtime.provider,
-                runtime.model,
-                request_messages,
-                call_tools,
-            )
-            if input_token_budget <= 0 or estimated > input_token_budget:
-                logger.debug(
-                    "Memory archive input does not fit for {}: {}/{} via {}; raw-dumping",
-                    session_key,
-                    estimated,
-                    input_token_budget,
-                    source,
-                )
-                return raw_fallback()
-
-        try:
-            with llm_usage_source("dream"):
-                response = await runtime.provider.chat_with_retry(
-                    model=runtime.model,
-                    messages=request_messages,
-                    tools=call_tools,
-                    temperature=runtime.generation.temperature,
-                    max_tokens=runtime.generation.max_tokens,
-                    reasoning_effort=runtime.generation.reasoning_effort,
-                    provider_context=provider_context,
-                )
-        except Exception:
-            logger.warning("Memory archive provider call failed, raw-dumping to history")
-            return raw_fallback()
-        if response.finish_reason in {"error", "length"}:
-            logger.warning(
-                "Memory archive provider did not complete ({}), raw-dumping to history",
-                response.finish_reason,
-            )
-            return raw_fallback()
-        if response.has_tool_calls is True:
-            logger.warning("Memory archive provider returned tool calls, raw-dumping to history")
-            return raw_fallback()
-        summary = response.content
-        if not summary or not summary.strip():
-            logger.warning("Memory archive provider returned no summary, raw-dumping to history")
-            return raw_fallback()
-        summary = self.store._normalize_history_entry(summary)
-        if not summary:
-            logger.warning("Memory archive provider summary was not safe to replay, raw-dumping")
-            return raw_fallback()
-        if summary == "(nothing)":
-            return "(nothing)"
-        self.store.append_history(summary, session_key=session_key)
-        return summary
-
-    async def archive_session(
-        self,
-        session: Session,
-        *,
-        archive_end: int,
-        runtime: LLMRuntime,
-        input_token_budget: int,
-    ) -> str | None:
-        """Archive a captured session prefix without mutating the session."""
-        messages = list(session.messages[session.last_archived:archive_end])
-        if not messages:
-            return None
-        session_summary = session_summary_from_metadata(
-            session.metadata,
-            fallback_last_active=session.updated_at,
-        )
-        previous_summary = session_summary["text"] if session_summary else None
-
-        if input_token_budget <= 0:
-            logger.debug(
-                "Memory archive has no safe input budget for {}; raw-dumping",
-                session.key,
-            )
-            return self._raw_checkpoint(
-                messages,
-                session_key=session.key,
-                previous_summary=previous_summary,
-                max_tokens=runtime.generation.max_tokens,
-            )
-        prefix = Session(
-            key=session.key,
-            messages=list(session.messages[:archive_end]),
-            last_consolidated=session.last_archived,
-        )
-        history = prefix.get_history(max_tokens=input_token_budget)
-        archive_history = Session(
-            key=session.key,
-            messages=messages,
-        ).get_history()
-        if not archive_history or history[-len(archive_history):] != archive_history:
-            logger.debug(
-                "Memory archive cannot replay the full chunk for {}; raw-dumping",
-                session.key,
-            )
-            return self._raw_checkpoint(
-                messages,
-                session_key=session.key,
-                previous_summary=previous_summary,
-                max_tokens=runtime.generation.max_tokens,
-            )
-        channel = session.key.split(":", 1)[0] if ":" in session.key else None
-        workspace: Path | None = None
-        if self._resolve_prompt_context is not None:
-            channel, workspace = self._resolve_prompt_context(session)
-        history_messages = self._build_messages(
-            history=history,
-            current_message=None,
-            channel=channel,
-            session_summary=session_summary,
-            workspace=workspace,
-        )
-        tools = self._get_tool_definitions()
-        return await self.archive(
-            messages,
-            runtime=runtime,
-            session_key=session.key,
-            history=history_messages,
-            request_tools=tools,
-            previous_summary=previous_summary,
-            input_token_budget=input_token_budget,
-        )
+# Individual history.jsonl writers cap their own payloads tightly; the
+# _HISTORY_ENTRY_HARD_CAP at append_history() is a belt-and-suspenders default
+# that catches any new caller that forgot to set its own cap.
+_RAW_ARCHIVE_MAX_CHARS = 16_000       # fallback dump (LLM failed)
+_ARCHIVE_SUMMARY_MAX_CHARS = 8_000    # LLM-produced consolidation summary
+_HISTORY_ENTRY_HARD_CAP = 64_000      # emergency cap in append_history
 
 
 class Consolidator:
-    """Coordinate session Memory checkpoints through ``MemoryArchiver``."""
+    """Summarize compacted messages into history.jsonl."""
+
+    _MAX_CONSOLIDATION_ROUNDS = 5
 
     _SAFETY_BUFFER = 1024  # extra headroom for tokenizer estimation drift
 
@@ -1020,17 +810,16 @@ class Consolidator:
         build_messages: Callable[..., list[dict[str, Any]]],
         get_tool_definitions: Callable[[], list[dict[str, Any]]],
         resolve_prompt_context: Callable[[Session], tuple[str | None, Path | None]] | None = None,
+        consolidation_ratio: float = 0.5,
+        unified_session: bool = False,
     ):
         self.store = store
         self.sessions = sessions
+        self.consolidation_ratio = consolidation_ratio
+        self.unified_session = unified_session
         self._build_messages = build_messages
         self._get_tool_definitions = get_tool_definitions
-        self.archiver = MemoryArchiver(
-            store=store,
-            build_messages=build_messages,
-            get_tool_definitions=get_tool_definitions,
-            resolve_prompt_context=resolve_prompt_context,
-        )
+        self._resolve_prompt_context = resolve_prompt_context
         self._locks: weakref.WeakValueDictionary[str, asyncio.Lock] = (
             weakref.WeakValueDictionary()
         )
@@ -1039,73 +828,27 @@ class Consolidator:
         """Return the shared consolidation lock for one session."""
         return self._locks.setdefault(session_key, asyncio.Lock())
 
-    async def summarize_transcript(
+    def pick_consolidation_boundary(
         self,
-        accepted_messages: list[dict[str, Any]],
-        previous_summary: str | None,
-        *,
-        runtime: LLMRuntime,
-        session_key: str,
-        tools: list[dict[str, Any]],
-        provider_state: ProviderConversationState | None = None,
-    ) -> str | None:
-        """Summarize the exact transcript prefix already accepted by the model."""
-        source_messages = [
-            dict(message)
-            for message in accepted_messages
-            if message.get("role") != "system"
-        ]
-        if not source_messages:
+        session: Session,
+        tokens_to_remove: int,
+    ) -> tuple[int, int] | None:
+        """Pick a user-turn boundary that removes enough old prompt tokens."""
+        start = session.last_consolidated
+        if start >= len(session.messages) or tokens_to_remove <= 0:
             return None
 
-        max_output_tokens = max(0, runtime.generation.max_tokens)
-        input_token_budget = runtime.context_window_tokens - max_output_tokens
-        checkpoint_tokens = min(
-            max_output_tokens,
-            max(1, (input_token_budget - self._SAFETY_BUFFER) // 2),
-        )
+        removed_tokens = 0
+        last_boundary: tuple[int, int] | None = None
+        for idx in range(start, len(session.messages)):
+            message = session.messages[idx]
+            if idx > start and message.get("role") == "user":
+                last_boundary = (idx, removed_tokens)
+                if removed_tokens >= tokens_to_remove:
+                    return last_boundary
+            removed_tokens += estimate_message_tokens(message)
 
-        summary = await self.archiver.archive(
-            source_messages,
-            runtime=runtime,
-            session_key=session_key,
-            history=accepted_messages,
-            request_tools=tools,
-            previous_summary=previous_summary,
-            input_token_budget=input_token_budget,
-            fallback_max_tokens=max(1, checkpoint_tokens),
-            provider_state=provider_state,
-        )
-        if summary == "(nothing)":
-            summary = self.archiver._raw_checkpoint(
-                source_messages,
-                session_key=session_key,
-                previous_summary=previous_summary,
-                max_tokens=max_output_tokens,
-            )
-        if summary is None:
-            return None
-        return truncate_text_to_tokens(summary, max(1, max_output_tokens))
-
-    async def summarize_provider_compaction(
-        self,
-        state: ProviderConversationState,
-        fallback_messages: list[dict[str, Any]],
-        previous_summary: str | None,
-        *,
-        runtime: LLMRuntime,
-        session_key: str,
-        tools: list[dict[str, Any]],
-    ) -> str | None:
-        """Prompt a native compacted state without replaying its raw history."""
-        return await self.summarize_transcript(
-            fallback_messages,
-            previous_summary,
-            runtime=runtime,
-            session_key=session_key,
-            tools=tools,
-            provider_state=state,
-        )
+        return last_boundary
 
     @staticmethod
     def _full_replay_history(
@@ -1116,18 +859,13 @@ class Consolidator:
             return []
         return session.get_history()
 
-    @staticmethod
-    def _set_last_summary(
-        session: Session,
-        summary: str,
-        *,
-        last_active: datetime | None = None,
-    ) -> None:
-        if summary != "(nothing)":
+    def _persist_last_summary(self, session: Session, summary: str | None) -> None:
+        if summary and summary != "(nothing)":
             session.metadata["_last_summary"] = {
                 "text": summary,
-                "last_active": (last_active or session.updated_at).isoformat(),
+                "last_active": session.updated_at.isoformat(),
             }
+            self.sessions.save(session)
 
     def estimate_session_prompt_tokens(
         self,
@@ -1147,6 +885,8 @@ class Consolidator:
             current_message="[token-probe]",
             channel=channel,
             session_summary=summary,
+            session_key=session.key,
+            unified_session=self.unified_session,
         )
         return estimate_prompt_tokens_chain(
             runtime.provider,
@@ -1163,6 +903,58 @@ class Consolidator:
             - self._SAFETY_BUFFER
         )
 
+    async def archive(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        runtime: LLMRuntime,
+        session_key: str,
+        request_messages: list[dict[str, Any]],
+        request_tools: list[dict[str, Any]],
+    ) -> str | None:
+        """Execute a prepared consolidation request and persist its result."""
+        if not messages:
+            return None
+        try:
+            with llm_usage_source("dream"):
+                response = await runtime.provider.chat_with_retry(
+                    model=runtime.model,
+                    messages=request_messages,
+                    tools=request_tools,
+                    tool_choice="none",
+                    temperature=runtime.generation.temperature,
+                    max_tokens=runtime.generation.max_tokens,
+                    reasoning_effort=runtime.generation.reasoning_effort,
+                )
+        except Exception:
+            logger.warning("Consolidation provider call failed, raw-dumping to history")
+            self.store.raw_archive(messages, session_key=session_key)
+            return None
+        if response.finish_reason in {"error", "length"}:
+            logger.warning(
+                "Consolidation provider did not complete ({}), raw-dumping to history",
+                response.finish_reason,
+            )
+            self.store.raw_archive(messages, session_key=session_key)
+            return None
+        if response.has_tool_calls is True:
+            logger.warning("Consolidation provider returned tool calls, raw-dumping to history")
+            self.store.raw_archive(messages, session_key=session_key)
+            return None
+        summary = response.content
+        if not summary or not summary.strip():
+            logger.warning("Consolidation provider returned no summary, raw-dumping to history")
+            self.store.raw_archive(messages, session_key=session_key)
+            return None
+        if summary.strip() == "(nothing)":
+            return "(nothing)"
+        self.store.append_history(
+            summary,
+            max_chars=_ARCHIVE_SUMMARY_MAX_CHARS,
+            session_key=session_key,
+        )
+        return summary
+
     async def archive_session(
         self,
         session: Session,
@@ -1170,13 +962,188 @@ class Consolidator:
         archive_end: int,
         runtime: LLMRuntime,
     ) -> str | None:
-        """Archive one captured session range through the shared Memory path."""
-        return await self.archiver.archive_session(
-            session,
-            archive_end=archive_end,
-            runtime=runtime,
-            input_token_budget=self._input_token_budget(runtime),
+        """Archive a session prefix by appending a consolidation instruction."""
+        messages = list(session.messages[session.last_consolidated:archive_end])
+        if not messages:
+            return None
+        budget = self._input_token_budget(runtime)
+        if budget <= 0:
+            logger.debug(
+                "Consolidation has no safe input budget for {}; raw-dumping",
+                session.key,
+            )
+            self.store.raw_archive(messages, session_key=session.key)
+            return None
+        prefix = Session(
+            key=session.key,
+            messages=list(session.messages[:archive_end]),
+            last_consolidated=session.last_consolidated,
         )
+        history = prefix.get_history(max_tokens=budget)
+        archive_history = Session(
+            key=session.key,
+            messages=messages,
+        ).get_history()
+        if (
+            not archive_history
+            or history[-len(archive_history):] != archive_history
+        ):
+            logger.debug(
+                "Consolidation cannot replay the full chunk for {}; raw-dumping",
+                session.key,
+            )
+            self.store.raw_archive(messages, session_key=session.key)
+            return None
+        prompt = render_template(
+            "agent/consolidator_archive.md",
+            strip=True,
+            archive_count=len(archive_history),
+        )
+        channel = session.key.split(":", 1)[0] if ":" in session.key else None
+        workspace: Path | None = None
+        if self._resolve_prompt_context is not None:
+            channel, workspace = self._resolve_prompt_context(session)
+        request_messages = self._build_messages(
+            history=history,
+            current_message=prompt,
+            channel=channel,
+            session_summary=session_summary_from_metadata(
+                session.metadata,
+                fallback_last_active=session.updated_at,
+            ),
+            workspace=workspace,
+            session_key=session.key,
+            unified_session=self.unified_session,
+        )
+        tools = self._get_tool_definitions()
+        estimated, source = estimate_prompt_tokens_chain(
+            runtime.provider,
+            runtime.model,
+            request_messages,
+            tools,
+        )
+        if estimated > budget:
+            logger.debug(
+                "Consolidation prefix exceeds budget for {}; raw-dumping: {}/{} via {}",
+                session.key,
+                estimated,
+                budget,
+                source,
+            )
+            self.store.raw_archive(messages, session_key=session.key)
+            return None
+        return await self.archive(
+            messages,
+            runtime=runtime,
+            session_key=session.key,
+            request_messages=request_messages,
+            request_tools=tools,
+        )
+
+    async def maybe_consolidate_by_tokens(
+        self,
+        session: Session,
+        *,
+        runtime: LLMRuntime,
+    ) -> None:
+        """Loop: archive old messages until prompt fits within safe budget.
+
+        The budget reserves space for completion tokens and a safety buffer
+        so the LLM request never exceeds the context window.
+        """
+        if runtime.context_window_tokens <= 0:
+            return
+
+        lock = self.get_lock(session.key)
+        async with lock:
+            # Refresh session reference: AutoCompact may have replaced it.
+            fresh = self.sessions.get_or_create(session.key)
+            if fresh is not session:
+                session = fresh
+            if not session.messages:
+                return
+
+            budget = self._input_token_budget(runtime)
+            target = int(budget * self.consolidation_ratio)
+            last_summary: str | None = None
+            estimated, source = self.estimate_session_prompt_tokens(
+                session,
+                runtime=runtime,
+            )
+            if estimated <= 0:
+                self._persist_last_summary(session, last_summary)
+                return
+            if estimated < budget:
+                unconsolidated_count = len(session.messages) - session.last_consolidated
+                logger.debug(
+                    "Token consolidation idle {}: {}/{} via {}, msgs={}",
+                    session.key,
+                    estimated,
+                    runtime.context_window_tokens,
+                    source,
+                    unconsolidated_count,
+                )
+                self._persist_last_summary(session, last_summary)
+                return
+
+            for round_num in range(self._MAX_CONSOLIDATION_ROUNDS):
+                if estimated <= target:
+                    break
+
+                boundary = self.pick_consolidation_boundary(session, max(1, estimated - target))
+                if boundary is None:
+                    logger.debug(
+                        "Token consolidation: no safe boundary for {} (round {})",
+                        session.key,
+                        round_num,
+                    )
+                    break
+
+                end_idx = boundary[0]
+
+                chunk = session.messages[session.last_consolidated:end_idx]
+                if not chunk:
+                    break
+
+                logger.info(
+                    "Token consolidation round {} for {}: {}/{} via {}, chunk={} msgs",
+                    round_num,
+                    session.key,
+                    estimated,
+                    runtime.context_window_tokens,
+                    source,
+                    len(chunk),
+                )
+                summary = await self.archive_session(
+                    session,
+                    archive_end=end_idx,
+                    runtime=runtime,
+                )
+                # Advance the cursor either way: on success the chunk was
+                # summarized; on failure archive_session() raw-archived it as
+                # a breadcrumb. Re-archiving the same chunk on the next call
+                # would just emit duplicate [RAW] entries.
+                if summary:
+                    last_summary = summary
+                session.last_consolidated = end_idx
+                session.provider_state = None
+                self.sessions.save(session)
+                if not summary:
+                    # LLM is degraded — stop hammering it this call;
+                    # the next invocation can retry a fresh chunk.
+                    break
+
+                estimated, source = self.estimate_session_prompt_tokens(
+                    session,
+                    runtime=runtime,
+                )
+                if estimated <= 0:
+                    break
+
+            # Persist the last summary to session metadata so it can be injected
+            # into the runtime context on the next prepare_session() call, aligning
+            # the summary injection strategy with AutoCompact._archive().
+            self._persist_last_summary(session, last_summary)
 
     async def compact_idle_session(
         self,
@@ -1203,7 +1170,7 @@ class Consolidator:
             self.sessions.invalidate(session_key)
             session = self.sessions.get_or_create(session_key)
 
-            archive_start = session.last_archived
+            archive_start = session.last_consolidated
             messages_to_archive = list(session.messages[archive_start:])
             if not messages_to_archive:
                 return ""
@@ -1215,14 +1182,17 @@ class Consolidator:
                 archive_end=archive_end,
                 runtime=runtime,
             )
-            if summary is None:
-                return None
 
-            self._set_last_summary(session, summary, last_active=last_active)
+            if summary and summary != "(nothing)":
+                session.metadata["_last_summary"] = {
+                    "text": summary,
+                    "last_active": last_active.isoformat(),
+                }
 
             # A turn can append while the provider call is in flight. Advance only
             # through the captured batch so new messages remain eligible next time.
-            session.last_archived = archive_end
+            session.last_consolidated = archive_end
+            session.provider_state = None
             self.sessions.save(session)
 
             visible = session.get_history(

nanobot/agent/subagent.py

@@ -55,8 +55,7 @@ class SubagentStatus:
     label: str
     task_description: str
     started_at: float          # time.monotonic()
-    # queued | initializing | awaiting_tools | tools_completed | final_response | done | error
-    phase: str = "initializing"
+    phase: str = "initializing"  # initializing | awaiting_tools | tools_completed | final_response | done | error
     iteration: int = 0
     tool_events: list[dict[str, str]] = field(default_factory=list)
     usage: LLMUsage | None = None
@@ -148,7 +147,6 @@ class SubagentManager:
             if max_concurrent_subagents is not None
             else defaults.max_concurrent_subagents
         )
-        self._run_slots = asyncio.Semaphore(self.max_concurrent_subagents)
         self.runner = AgentRunner()
         self._exec_session_manager = ExecSessionManager()
         self._llm_wall_timeout_for_session = llm_wall_timeout_for_session
@@ -365,35 +363,6 @@ class SubagentManager:
         workspace_scope: WorkspaceScope | None = None,
         *,
         announce: bool = True,
-    ) -> str:
-        """Wait for capacity, then execute one subagent task."""
-        status.phase = "queued"
-        async with self._run_slots:
-            status.phase = "initializing"
-            return await self._run_admitted_subagent(
-                task_id,
-                task,
-                label,
-                origin,
-                status,
-                runtime,
-                origin_message_id,
-                workspace_scope,
-                announce=announce,
-            )
-
-    async def _run_admitted_subagent(
-        self,
-        task_id: str,
-        task: str,
-        label: str,
-        origin: _SubagentOrigin,
-        status: SubagentStatus,
-        runtime: LLMRuntime,
-        origin_message_id: str | None = None,
-        workspace_scope: WorkspaceScope | None = None,
-        *,
-        announce: bool = True,
     ) -> str:
         """Execute the subagent task and announce the result."""
         logger.info("Subagent [{}] starting task: {}", task_id, label)

nanobot/agent/tools/context.py

@@ -11,7 +11,6 @@ if TYPE_CHECKING:
     from nanobot.agent.subagent import SubagentManager
     from nanobot.agent.tools.exec_session import ExecSessionManager
     from nanobot.agent.tools.file_state import FileStates
-    from nanobot.agent.tools.runtime_control import RuntimeControl
     from nanobot.bus.queue import MessageBus
     from nanobot.bus.runtime_events import RuntimeEventBus
     from nanobot.config.schema import ProviderConfig, ToolsConfig
@@ -91,4 +90,3 @@ class ToolContext:
     timezone: str = "UTC"
     workspace_sandbox: WorkspaceSandboxStatus | None = None
     runtime_events: RuntimeEventBus | None = None
-    runtime_control: RuntimeControl | None = None

nanobot/agent/tools/execution.py

@@ -1,293 +0,0 @@
-"""Execute tool calls and turn their outcomes into model observations."""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Callable
-from typing import Any, cast
-
-from loguru import logger
-
-from nanobot.agent.hook import AgentHook, AgentHookContext
-from nanobot.agent.tools.registry import ToolRegistry, is_tool_error_result
-from nanobot.providers.base import ToolCallRequest
-from nanobot.utils.runtime import (
-    repeated_external_lookup_error,
-    repeated_workspace_violation_error,
-)
-
-_RETRY_HINT = "\n\n[Analyze the error above and try a different approach.]"
-# SSRF is a hard security block at the tool boundary, but the agent turn
-# should recover conversationally instead of aborting the runtime.
-_SSRF_MARKERS: tuple[str, ...] = (
-    "internal/private url detected",
-    "private/internal address",
-    "private address",
-)
-_SSRF_BOUNDARY_NOTE = (
-    "This is a non-bypassable security boundary. Stop trying to access "
-    "private/internal URLs. Do not retry with curl, wget, encoded IPs, "
-    "alternate DNS, redirects, proxies, or another tool. Ask the user for "
-    "local files, logs, screenshots, or an explicit safe public URL instead. "
-    "If the user explicitly trusts this private URL, ask them to whitelist "
-    "the exact IP/CIDR via tools.ssrfWhitelist."
-)
-# Non-SSRF boundary markers returned to the model as recoverable tool errors.
-_WORKSPACE_VIOLATION_MARKERS: tuple[str, ...] = (
-    "outside the configured workspace",
-    "outside allowed directory",
-    "working_dir is outside",
-    "working_dir could not be resolved",
-    "path outside working dir",
-    "path traversal detected",
-)
-
-
-def _with_retry_hint(payload: str) -> str:
-    """Append the recovery hint exactly once."""
-    if payload.endswith(_RETRY_HINT):
-        return payload
-    return payload + _RETRY_HINT
-
-
-async def execute_tool_calls(
-    tools: ToolRegistry,
-    tool_calls: list[ToolCallRequest],
-    *,
-    concurrent: bool,
-    external_lookup_counts: dict[str, int],
-    workspace_violation_counts: dict[str, int],
-    hook: AgentHook,
-    context: AgentHookContext,
-) -> tuple[list[Any], list[dict[str, str]]]:
-    """Execute one model response's tool calls in stable result order."""
-    tool_results: list[tuple[Any, dict[str, str]]] = []
-    for batch in _partition_tool_batches(tools, tool_calls, concurrent=concurrent):
-        if concurrent and len(batch) > 1:
-            batch_results = await asyncio.gather(*(
-                _execute_tool_call(
-                    tools,
-                    tool_call,
-                    external_lookup_counts,
-                    workspace_violation_counts,
-                    hook,
-                    context,
-                )
-                for tool_call in batch
-            ))
-            tool_results.extend(batch_results)
-        else:
-            for tool_call in batch:
-                result = await _execute_tool_call(
-                    tools,
-                    tool_call,
-                    external_lookup_counts,
-                    workspace_violation_counts,
-                    hook,
-                    context,
-                )
-                tool_results.append(result)
-
-    results = [result for result, _event in tool_results]
-    events = [event for _result, event in tool_results]
-    return results, events
-
-
-async def _execute_tool_call(
-    tools: ToolRegistry,
-    tool_call: ToolCallRequest,
-    external_lookup_counts: dict[str, int],
-    workspace_violation_counts: dict[str, int],
-    hook: AgentHook,
-    context: AgentHookContext,
-) -> tuple[Any, dict[str, str]]:
-    lookup_error = repeated_external_lookup_error(
-        tool_call.name,
-        tool_call.arguments,
-        external_lookup_counts,
-    )
-    if lookup_error:
-        event = {
-            "name": tool_call.name,
-            "status": "error",
-            "detail": "repeated external lookup blocked",
-        }
-        return _with_retry_hint(lookup_error), event
-
-    prepare_call = cast(
-        Callable[[str, Any], object] | None,
-        getattr(tools, "prepare_call", None),
-    )
-    tool, params, prep_error = None, tool_call.arguments, None
-    if callable(prepare_call):
-        prepared = prepare_call(tool_call.name, tool_call.arguments)
-        if isinstance(prepared, tuple):
-            prepared_tuple = cast(tuple[object, ...], prepared)
-            if len(prepared_tuple) == 3:
-                tool, params, prep_error = cast(tuple[Any, Any, str | None], prepared_tuple)
-    if prep_error:
-        payload = _with_retry_hint(prep_error)
-        event = {
-            "name": tool_call.name,
-            "status": "error",
-            "detail": prep_error.split(": ", 1)[-1][:120],
-        }
-        handled = _classify_violation(
-            raw_text=prep_error,
-            soft_payload=payload,
-            event=event,
-            tool_call=tool_call,
-            workspace_violation_counts=workspace_violation_counts,
-        )
-        if handled is not None:
-            return handled
-        return payload, event
-
-    await hook.before_execute_tool(context, tool_call, tool, params)
-    try:
-        if tool is not None:
-            result = await tool.execute(**params)
-        else:
-            result = await tools.execute(tool_call.name, params)
-    except asyncio.CancelledError:
-        raise
-    except Exception as exc:
-        await hook.on_execute_tool_error(context, tool_call, tool, params, exc)
-        event = {
-            "name": tool_call.name,
-            "status": "error",
-            "detail": str(exc),
-        }
-        payload = _with_retry_hint(f"Error: {type(exc).__name__}: {exc}")
-        handled = _classify_violation(
-            raw_text=str(exc),
-            soft_payload=payload,
-            event=event,
-            tool_call=tool_call,
-            workspace_violation_counts=workspace_violation_counts,
-        )
-        if handled is not None:
-            return handled
-        return payload, event
-
-    if is_tool_error_result(result):
-        await hook.on_execute_tool_error(context, tool_call, tool, params, result)
-        payload = _with_retry_hint(result)
-        event = {
-            "name": tool_call.name,
-            "status": "error",
-            "detail": result.replace("\n", " ").strip()[:120],
-        }
-        handled = _classify_violation(
-            raw_text=result,
-            soft_payload=payload,
-            event=event,
-            tool_call=tool_call,
-            workspace_violation_counts=workspace_violation_counts,
-        )
-        if handled is not None:
-            return handled
-        return payload, event
-
-    await hook.after_execute_tool(context, tool_call, tool, params, result)
-
-    detail = "" if result is None else str(result)
-    detail = detail.replace("\n", " ").strip()
-    if not detail:
-        detail = "(empty)"
-    elif len(detail) > 120:
-        detail = detail[:120] + "..."
-    return result, {"name": tool_call.name, "status": "ok", "detail": detail}
-
-
-def is_ssrf_violation(text: str) -> bool:
-    """Return whether a tool error describes a blocked private-network request."""
-    if not text:
-        return False
-    lowered = text.lower()
-    return any(marker in lowered for marker in _SSRF_MARKERS)
-
-
-def _is_workspace_violation(text: str) -> bool:
-    """Return whether text describes any workspace or network boundary rejection."""
-    if not text:
-        return False
-    lowered = text.lower()
-    if is_ssrf_violation(lowered):
-        return True
-    return any(marker in lowered for marker in _WORKSPACE_VIOLATION_MARKERS)
-
-
-def _classify_violation(
-    *,
-    raw_text: str,
-    soft_payload: str,
-    event: dict[str, str],
-    tool_call: ToolCallRequest,
-    workspace_violation_counts: dict[str, int],
-) -> tuple[Any, dict[str, str]] | None:
-    if is_ssrf_violation(raw_text):
-        logger.warning(
-            "Tool {} blocked by SSRF guard; returning non-retryable tool error: {}",
-            tool_call.name,
-            raw_text.replace("\n", " ").strip()[:200],
-        )
-        event["detail"] = _event_detail("ssrf_violation: ", raw_text)
-        return _ssrf_soft_payload(raw_text), event
-
-    if _is_workspace_violation(raw_text):
-        escalation = repeated_workspace_violation_error(
-            tool_call.name,
-            tool_call.arguments,
-            workspace_violation_counts,
-        )
-        event["detail"] = _event_detail("workspace_violation: ", raw_text)
-        if escalation is not None:
-            logger.warning(
-                "Tool {} hit workspace boundary repeatedly; escalating hint",
-                tool_call.name,
-            )
-            event["detail"] = _event_detail(
-                "workspace_violation_escalated: ",
-                raw_text,
-            )
-            return escalation, event
-        return soft_payload, event
-
-    return None
-
-
-def _ssrf_soft_payload(raw_text: str) -> str:
-    text = raw_text.strip() or "Error: request blocked by SSRF guard"
-    return f"{text}\n\n{_SSRF_BOUNDARY_NOTE}"
-
-
-def _event_detail(prefix: str, text: str, limit: int = 160) -> str:
-    return (prefix + text.replace("\n", " ").strip())[:limit]
-
-
-def _partition_tool_batches(
-    tools: ToolRegistry,
-    tool_calls: list[ToolCallRequest],
-    *,
-    concurrent: bool,
-) -> list[list[ToolCallRequest]]:
-    if not concurrent:
-        return [[tool_call] for tool_call in tool_calls]
-
-    batches: list[list[ToolCallRequest]] = []
-    current: list[ToolCallRequest] = []
-    for tool_call in tool_calls:
-        get_tool = cast(Callable[[str], Any] | None, getattr(tools, "get", None))
-        tool = get_tool(tool_call.name) if callable(get_tool) else None
-        can_batch = bool(tool and tool.concurrency_safe)
-        if can_batch:
-            current.append(tool_call)
-            continue
-        if current:
-            batches.append(current)
-            current = []
-        batches.append([tool_call])
-    if current:
-        batches.append(current)
-    return batches

nanobot/agent/tools/filesystem.py

@@ -861,10 +861,8 @@ def _best_window(old_text: str, content: str) -> tuple[float, int, list[str], li
 @tool_parameters(
     tool_parameters_schema(
         path=StringSchema("The file path to edit"),
-        old_text=StringSchema("The text to find and replace; copy it from read_file."),
-        new_text=StringSchema(
-            "The replacement text; must differ from old_text for an existing file."
-        ),
+        old_text=StringSchema("The text to find and replace"),
+        new_text=StringSchema("The text to replace with"),
         replace_all=BooleanSchema(description="Replace all occurrences (default false)"),
         occurrence=IntegerSchema(
             description="Optional 1-based occurrence to replace when old_text appears multiple times.",
@@ -901,9 +899,15 @@ class EditFileTool(_FsTool):
     @property
     def description(self) -> str:
         return (
-            "Perform a small, exact replacement in one file. "
-            "Prefer apply_patch for multi-file, structural, or generated edits. "
-            "occurrence, line_hint, and replace_all=true are mutually exclusive."
+            "Perform a small, exact replacement in one file by replacing "
+            "old_text with new_text. When replacing text in an existing file, "
+            "old_text and new_text must be different. Use this for narrow text substitutions "
+            "with old_text copied from read_file. For multi-file, structural, "
+            "or generated code edits, prefer apply_patch. If old_text matches "
+            "multiple times, provide more context or set occurrence, line_hint, "
+            "replace_all, and expected_replacements. When editing from numbered "
+            "read_file output, set line_hint to the exact target line. "
+            "Shows closest-match diagnostics on failure."
         )
 
     @staticmethod

nanobot/agent/tools/message.py

@@ -2,11 +2,9 @@
 
 # pyright: reportIncompatibleMethodOverride=false
 
-from collections.abc import Awaitable, Callable, Generator
-from contextlib import contextmanager
 from contextvars import ContextVar, Token
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, Awaitable, Callable, cast
 
 from loguru import logger
 
@@ -18,22 +16,6 @@ from nanobot.bus.events import OutboundMessage
 from nanobot.config.paths import get_workspace_path
 from nanobot.security.workspace_access import current_tool_workspace
 
-_CURRENT_MESSAGE_SENDS: ContextVar[set[tuple[str, str]] | None] = ContextVar(
-    "message_sends",
-    default=None,
-)
-
-
-@contextmanager
-def capture_message_deliveries() -> Generator[set[tuple[str, str]], None, None]:
-    """Record successful MessageTool targets within one agent run."""
-    sends: set[tuple[str, str]] = set()
-    token = _CURRENT_MESSAGE_SENDS.set(sends)
-    try:
-        yield sends
-    finally:
-        _CURRENT_MESSAGE_SENDS.reset(token)
-
 
 @tool_parameters(
     tool_parameters_schema(
@@ -86,6 +68,7 @@ class MessageTool(Tool):
         self._fallback_chat_id = default_chat_id
         self._fallback_message_id = default_message_id
         self._fallback_metadata: dict[str, Any] = {}
+        self._sent_in_turn_var: ContextVar[bool] = ContextVar("message_sent_in_turn", default=False)
         self._suppress_delivery_var: ContextVar[bool] = ContextVar(
             "message_suppress_delivery",
             default=False,
@@ -104,6 +87,10 @@ class MessageTool(Tool):
         """Set the callback for sending messages."""
         self._send_callback = callback
 
+    def start_turn(self) -> None:
+        """Reset per-turn send tracking."""
+        self._sent_in_turn = False
+
     def set_suppress_delivery(self, active: bool) -> Token[bool]:
         """Acknowledge but don't deliver tool sends (heartbeat internal check)."""
         return self._suppress_delivery_var.set(active)
@@ -112,6 +99,14 @@ class MessageTool(Tool):
         """Restore previous delivery-suppression state."""
         self._suppress_delivery_var.reset(token)
 
+    @property
+    def _sent_in_turn(self) -> bool:
+        return self._sent_in_turn_var.get()
+
+    @_sent_in_turn.setter
+    def _sent_in_turn(self, value: bool) -> None:
+        self._sent_in_turn_var.set(value)
+
     @property
     def name(self) -> str:
         return "message"
@@ -249,9 +244,8 @@ class MessageTool(Tool):
 
         try:
             await self._send_callback(msg)
-            sends = _CURRENT_MESSAGE_SENDS.get()
-            if sends is not None:
-                sends.add((channel, chat_id))
+            if channel == default_channel and chat_id == default_chat_id:
+                self._sent_in_turn = True
             media_info = f" with {len(media)} attachments" if media else ""
             button_info = (
                 f" with {sum(len(row) for row in button_rows)} button(s)"

nanobot/agent/tools/self.py

@@ -58,6 +58,7 @@ def _is_string_mapping(value: object) -> TypeGuard[Mapping[str, object]]:
 class MyTool(Tool):
     """Check and set the agent loop's runtime configuration."""
 
+    _plugin_discoverable = False  # Requires AgentLoop reference; registered manually
     config_key = "my"
 
     @classmethod
@@ -66,16 +67,7 @@ class MyTool(Tool):
 
     @classmethod
     def enabled(cls, ctx: ToolContext) -> bool:
-        return ctx.runtime_control is not None and ctx.config.my.enable
-
-    @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        if ctx.runtime_control is None:
-            raise RuntimeError("MyTool requires a runtime control capability")
-        return cls(
-            runtime_control=ctx.runtime_control,
-            modify_allowed=ctx.config.my.allow_set,
-        )
+        return ctx.config.my.enable
 
     BLOCKED = frozenset({
         # Core infrastructure

nanobot/agent/tools/session_messages.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import asyncio
 import json
 import time
-from collections import OrderedDict, deque
+from collections import deque
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Protocol
@@ -127,7 +127,7 @@ class SendSessionMessageTool(Tool):
         self._max_messages_per_minute = max_messages_per_minute
         self._schedule_later = schedule_later
         self._clock = clock or time.monotonic
-        self._sent_at: OrderedDict[str, deque[float]] = OrderedDict()
+        self._sent_at: dict[str, deque[float]] = {}
         self._pending_replies: dict[tuple[str, str], _PendingReply] = {}
         self._expiry_tasks: set[asyncio.Task[None]] = set()
         self._send_lock = asyncio.Lock()
@@ -240,11 +240,8 @@ class SendSessionMessageTool(Tool):
 
         async with self._send_lock:
             now = self._clock()
+            sent_at = self._sent_at.setdefault(source.session_key, deque())
             cutoff = now - _RATE_LIMIT_WINDOW_SECONDS
-            self._prune_expired_rate_limits(cutoff)
-            sent_at = self._sent_at.get(source.session_key)
-            if sent_at is None:
-                sent_at = deque[float]()
             while sent_at and sent_at[0] <= cutoff:
                 sent_at.popleft()
             if len(sent_at) >= self._max_messages_per_minute:
@@ -262,8 +259,6 @@ class SendSessionMessageTool(Tool):
                 input_role="user",
             ))
             sent_at.append(now)
-            self._sent_at[source.session_key] = sent_at
-            self._sent_at.move_to_end(source.session_key)
             self._cancel_pending_reply(reverse_wait_key)
             if timeout_seconds is not None:
                 self._cancel_pending_reply(wait_key)
@@ -276,14 +271,6 @@ class SendSessionMessageTool(Tool):
 
         return f"@{target.name}"
 
-    def _prune_expired_rate_limits(self, cutoff: float) -> None:
-        """Drop sources ordered by their most recent successful send."""
-        while self._sent_at:
-            _, sent_at = next(iter(self._sent_at.items()))
-            if sent_at[-1] > cutoff:
-                return
-            self._sent_at.popitem(last=False)
-
     @staticmethod
     def _validate_reply_timeout(
         expect_reply: bool,

nanobot/agent/tools/spawn.py

@@ -73,11 +73,6 @@ class SpawnTool(Tool):
             "and use a dedicated subdirectory when helpful."
         )
 
-    @property
-    def concurrency_safe(self) -> bool:
-        """Each call owns its task state; the manager serializes capacity admission."""
-        return True
-
     async def execute(
         self,
         task: str,
@@ -87,6 +82,14 @@ class SpawnTool(Tool):
         **kwargs: Any,
     ) -> str:
         """Spawn a subagent to execute the given task."""
+        running = self._manager.get_running_count()
+        limit = self._manager.max_concurrent_subagents
+        if running >= limit:
+            return (
+                f"Cannot spawn subagent: concurrency limit reached "
+                f"({running}/{limit} running). Wait for a running subagent "
+                f"to complete before spawning a new one."
+            )
         request_ctx = current_request_context()
         if request_ctx is None or request_ctx.runtime is None:
             return ToolResult.error("Error: spawn requires an active model runtime")

nanobot/channels/dingtalk/runtime.py

@@ -182,12 +182,6 @@ class NanobotDingTalkHandler(_CallbackHandlerBase):
                 )
             )
 
-            if not self.channel._accepting_inbound_tasks:
-                self.channel.logger.debug(
-                    "Skipping DingTalk inbound dispatch during channel shutdown"
-                )
-                return AckMessage.STATUS_OK, "OK"
-
             self.channel.logger.info("Received message from {} ({}): {}", sender_name, sender_id, content)
 
             # Forward to Nanobot via _on_message (non-blocking).
@@ -202,7 +196,7 @@ class NanobotDingTalkHandler(_CallbackHandlerBase):
                 )
             )
             self.channel._background_tasks.add(task)
-            task.add_done_callback(self.channel._on_background_task_done)
+            task.add_done_callback(self.channel._background_tasks.discard)
 
             return AckMessage.STATUS_OK, "OK"
 
@@ -262,17 +256,6 @@ class DingTalkChannel(BaseChannel):
 
         # Hold references to background tasks to prevent GC
         self._background_tasks: set[asyncio.Task[None]] = set()
-        self._accepting_inbound_tasks = True
-
-    def _on_background_task_done(self, task: asyncio.Task[None]) -> None:
-        self._background_tasks.discard(task)
-        if task.cancelled():
-            return
-        exception = task.exception()
-        if exception is not None:
-            self.logger.opt(exception=exception).error(
-                "DingTalk inbound message task failed"
-            )
 
     async def start(self) -> None:
         """Start the DingTalk bot with Stream Mode."""
@@ -289,7 +272,6 @@ class DingTalkChannel(BaseChannel):
                 self.logger.error("client_id and client_secret not configured")
                 return
 
-            self._accepting_inbound_tasks = True
             self._running = True
             self._http = httpx.AsyncClient(
                 timeout=httpx.Timeout(10.0, connect=10.0, read=30.0, write=30.0, pool=10.0)
@@ -327,7 +309,6 @@ class DingTalkChannel(BaseChannel):
 
     async def stop(self) -> None:
         """Stop the DingTalk bot."""
-        self._accepting_inbound_tasks = False
         self._running = False
         await self._close_stream_client()
         start_task = self._start_task
@@ -345,11 +326,8 @@ class DingTalkChannel(BaseChannel):
             await self._http.aclose()
             self._http = None
         # Cancel outstanding background tasks
-        background_tasks = tuple(self._background_tasks)
-        for task in background_tasks:
+        for task in self._background_tasks:
             task.cancel()
-        if background_tasks:
-            await asyncio.gather(*background_tasks, return_exceptions=True)
         self._background_tasks.clear()
 
     async def _close_stream_client(self) -> None:

nanobot/channels/dingtalk/tests/test_dingtalk_channel.py

@@ -3,7 +3,7 @@ import json
 import zipfile
 from io import BytesIO
 from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock
 
 import httpx
 import pytest
@@ -402,61 +402,6 @@ async def test_handler_uses_voice_recognition_text_when_text_is_empty(monkeypatc
     assert msg.chat_id == "group:conv123"
 
 
-@pytest.mark.asyncio
-async def test_handler_retrieves_background_message_failure(monkeypatch) -> None:
-    bus = MessageBus()
-    channel = DingTalkChannel(
-        DingTalkConfig(client_id="app", client_secret="secret", allow_from=["user1"]),
-        bus,
-    )
-    handler = NanobotDingTalkHandler(channel)
-    failure = RuntimeError("inbound dispatch failed")
-    mock_logger = MagicMock()
-    channel.logger = mock_logger
-
-    class _FakeChatbotMessage:
-        text = SimpleNamespace(content="hello")
-        extensions = {}
-        sender_staff_id = "user1"
-        sender_id = "fallback-user"
-        sender_nick = "Alice"
-        message_type = "text"
-
-        @staticmethod
-        def from_dict(_data):
-            return _FakeChatbotMessage()
-
-    async def fail(*_args) -> None:
-        raise failure
-
-    monkeypatch.setattr(dingtalk_module, "ChatbotMessage", _FakeChatbotMessage)
-    monkeypatch.setattr(dingtalk_module, "AckMessage", SimpleNamespace(STATUS_OK="OK"))
-    monkeypatch.setattr(channel, "_on_message", fail)
-    event_loop = asyncio.get_running_loop()
-    previous_handler = event_loop.get_exception_handler()
-    loop_errors: list[dict[str, object]] = []
-    event_loop.set_exception_handler(lambda _loop, context: loop_errors.append(context))
-
-    try:
-        status, body = await handler.process(
-            SimpleNamespace(data={"conversationType": "1", "text": {"content": "hello"}})
-        )
-        for _ in range(10):
-            await asyncio.sleep(0)
-            if not channel._background_tasks:
-                break
-    finally:
-        event_loop.set_exception_handler(previous_handler)
-
-    assert (status, body) == ("OK", "OK")
-    assert not channel._background_tasks
-    assert not loop_errors
-    mock_logger.opt.assert_called_once_with(exception=failure)
-    mock_logger.opt.return_value.error.assert_called_once_with(
-        "DingTalk inbound message task failed"
-    )
-
-
 @pytest.mark.asyncio
 async def test_handler_processes_file_message(monkeypatch) -> None:
     """Test that file messages are handled and forwarded with downloaded path."""
@@ -506,72 +451,6 @@ async def test_handler_processes_file_message(monkeypatch) -> None:
     assert "/tmp/nanobot_dingtalk/user1/report.xlsx" in msg.content
 
 
-@pytest.mark.asyncio
-async def test_handler_does_not_spawn_message_task_after_stop_during_download(
-    monkeypatch,
-) -> None:
-    channel = DingTalkChannel(
-        DingTalkConfig(client_id="app", client_secret="secret", allow_from=["user1"]),
-        MessageBus(),
-    )
-    handler = NanobotDingTalkHandler(channel)
-    download_started = asyncio.Event()
-    release_download = asyncio.Event()
-    message_task_started = asyncio.Event()
-
-    class _FakeFileChatbotMessage:
-        text = None
-        extensions = {}
-        image_content = None
-        rich_text_content = None
-        sender_staff_id = "user1"
-        sender_id = "fallback-user"
-        sender_nick = "Alice"
-        message_type = "file"
-
-        @staticmethod
-        def from_dict(_data):
-            return _FakeFileChatbotMessage()
-
-    async def delayed_download(*_args):
-        download_started.set()
-        await release_download.wait()
-        return "/tmp/nanobot_dingtalk/user1/report.xlsx"
-
-    async def block_message(*_args) -> None:
-        message_task_started.set()
-        await asyncio.Future()
-
-    monkeypatch.setattr(dingtalk_module, "ChatbotMessage", _FakeFileChatbotMessage)
-    monkeypatch.setattr(dingtalk_module, "AckMessage", SimpleNamespace(STATUS_OK="OK"))
-    monkeypatch.setattr(channel, "_download_dingtalk_file", delayed_download)
-    monkeypatch.setattr(channel, "_on_message", block_message)
-
-    process_task = asyncio.create_task(handler.process(SimpleNamespace(data={
-        "conversationType": "1",
-        "content": {"downloadCode": "abc123", "fileName": "report.xlsx"},
-        "text": {"content": ""},
-    })))
-    await download_started.wait()
-
-    try:
-        await channel.stop()
-        release_download.set()
-        assert await process_task == ("OK", "OK")
-        await asyncio.sleep(0)
-
-        assert not message_task_started.is_set()
-        assert not channel._background_tasks
-    finally:
-        release_download.set()
-        if not process_task.done():
-            process_task.cancel()
-        pending = tuple(channel._background_tasks)
-        for task in pending:
-            task.cancel()
-        await asyncio.gather(process_task, *pending, return_exceptions=True)
-
-
 def _rich_text_message(rich_text_list):
     class _FakeRichTextChatbotMessage:
         text = None
@@ -771,41 +650,6 @@ async def test_stop_cancels_stream_client_after_sdk_swallows_first_cancel(monkey
     assert start_task.cancelled()
 
 
-@pytest.mark.asyncio
-async def test_stop_waits_for_background_message_tasks() -> None:
-    channel = DingTalkChannel(
-        DingTalkConfig(client_id="app", client_secret="secret", allow_from=["*"]),
-        MessageBus(),
-    )
-    mock_logger = MagicMock()
-    channel.logger = mock_logger
-    started = asyncio.Event()
-    cancelled = asyncio.Event()
-
-    async def wait_forever() -> None:
-        started.set()
-        try:
-            await asyncio.Future()
-        finally:
-            cancelled.set()
-
-    task = asyncio.create_task(wait_forever())
-    channel._background_tasks.add(task)
-    task.add_done_callback(channel._on_background_task_done)
-    await started.wait()
-
-    try:
-        await channel.stop()
-        assert task.done()
-        assert cancelled.is_set()
-        assert not channel._background_tasks
-        mock_logger.opt.assert_not_called()
-    finally:
-        if not task.done():
-            task.cancel()
-        await asyncio.gather(task, return_exceptions=True)
-
-
 @pytest.mark.asyncio
 async def test_download_dingtalk_file(tmp_path, monkeypatch) -> None:
     """Test the two-step file download flow (get URL then download content)."""

nanobot/channels/email/runtime.py

@@ -430,13 +430,7 @@ class EmailChannel(BaseChannel):
         skipped_uids: set[str],
         cycle_uids: set[str],
     ) -> list[dict[str, Any]] | None:
-        """Fetch messages by arbitrary IMAP search criteria.
-
-        Uses UID SEARCH so already-processed UIDs are recognized before any
-        FETCH at all, then fetches headers only to evaluate every filter — the
-        full body (and any attachments) is downloaded only for messages that
-        pass every check and are actually going to be delivered.
-        """
+        """Fetch messages by arbitrary IMAP search criteria."""
         mailbox = self.config.imap_mailbox or "INBOX"
 
         client = self._open_imap_client(mailbox=mailbox, missing_mailbox_ok=True)
@@ -444,30 +438,29 @@ class EmailChannel(BaseChannel):
             return messages
 
         try:
-            status, data = client.uid("SEARCH", None, *search_criteria)
-            if status != "OK" or not data or not data[0]:
+            status, data = client.search(None, *search_criteria)
+            if status != "OK" or not data:
                 return messages
 
-            uids = [raw.decode("ascii", errors="ignore") for raw in data[0].split()]
-            if limit > 0 and len(uids) > limit:
-                uids = uids[-limit:]
-
-            features: _ServerFeatures | None = None
-
-            for uid in uids:
-                if not uid or uid in cycle_uids:
-                    continue
-                if dedupe and uid in self._processed_uids:
-                    continue
-
-                status, fetched = client.uid("FETCH", uid, "(BODY.PEEK[HEADER])")
+            ids = data[0].split()
+            if limit > 0 and len(ids) > limit:
+                ids = ids[-limit:]
+            for imap_id in ids:
+                status, fetched = client.fetch(imap_id, "(BODY.PEEK[] UID)")
                 if status != "OK" or not fetched:
                     continue
-                header_bytes = self._extract_message_bytes(fetched)
-                if header_bytes is None:
+
+                raw_bytes = self._extract_message_bytes(fetched)
+                if raw_bytes is None:
                     continue
 
-                parsed = BytesParser(policy=policy.default).parsebytes(header_bytes)
+                uid = self._extract_uid(fetched)
+                if uid and uid in cycle_uids:
+                    continue
+                if dedupe and uid and uid in self._processed_uids:
+                    continue
+
+                parsed = BytesParser(policy=policy.default).parsebytes(raw_bytes)
                 sender = parseaddr(parsed.get("From", ""))[1].strip().lower()
                 if not sender:
                     continue
@@ -475,8 +468,9 @@ class EmailChannel(BaseChannel):
                     self.logger.info("From {} ignored: matches bot-owned address", sender)
                     self._remember_processed_uid(uid, dedupe, cycle_uids)
                     if mark_seen:
-                        features = self._mark_seen_uid(client, uid, features)
-                    skipped_uids.add(uid)
+                        client.store(imap_id, "+FLAGS", "\\Seen")
+                    if uid:
+                        skipped_uids.add(uid)
                     continue
 
                 # --- Anti-spoofing: verify Authentication-Results ---
@@ -488,7 +482,8 @@ class EmailChannel(BaseChannel):
                         sender,
                     )
                     self._remember_processed_uid(uid, dedupe, cycle_uids)
-                    skipped_uids.add(uid)
+                    if uid:
+                        skipped_uids.add(uid)
                     continue
                 if self.config.verify_dkim and not dkim_pass:
                     self.logger.warning(
@@ -497,26 +492,18 @@ class EmailChannel(BaseChannel):
                         sender,
                     )
                     self._remember_processed_uid(uid, dedupe, cycle_uids)
-                    skipped_uids.add(uid)
+                    if uid:
+                        skipped_uids.add(uid)
                     continue
 
                 if not self.is_allowed(sender):
                     self._remember_processed_uid(uid, dedupe, cycle_uids)
                     if mark_seen:
-                        features = self._mark_seen_uid(client, uid, features)
-                    skipped_uids.add(uid)
+                        client.store(imap_id, "+FLAGS", "\\Seen")
+                    if uid:
+                        skipped_uids.add(uid)
                     continue
 
-                # Passed every filter — only now fetch the full message body
-                # (and any attachments) for the message we're actually delivering.
-                status, full_fetched = client.uid("FETCH", uid, "(BODY.PEEK[])")
-                if status != "OK" or not full_fetched:
-                    continue
-                raw_bytes = self._extract_message_bytes(full_fetched)
-                if raw_bytes is None:
-                    continue
-                parsed = BytesParser(policy=policy.default).parsebytes(raw_bytes)
-
                 subject = self._decode_header_value(parsed.get("Subject", ""))
                 date_value = parsed.get("Date", "")
                 message_id = parsed.get("Message-ID", "").strip()
@@ -569,19 +556,10 @@ class EmailChannel(BaseChannel):
                 self._remember_processed_uid(uid, dedupe, cycle_uids)
 
                 if mark_seen:
-                    features = self._mark_seen_uid(client, uid, features)
+                    client.store(imap_id, "+FLAGS", "\\Seen")
         finally:
             self._close_imap_client(client)
 
-    def _mark_seen_uid(
-        self, client: Any, uid: str, features: _ServerFeatures | None
-    ) -> _ServerFeatures:
-        """Mark a single UID \\Seen, reusing session-learned STORE support."""
-        if features is None:
-            features = self._server_features(client)
-        self._uid_store_flag(client, uid, "\\Seen", features)
-        return features
-
     def _open_imap_client(self, mailbox: str, *, missing_mailbox_ok: bool = False) -> Any | None:
         if self.config.imap_use_ssl:
             client: Any = imaplib.IMAP4_SSL(self.config.imap_host, self.config.imap_port)
@@ -736,14 +714,11 @@ class EmailChannel(BaseChannel):
         return data[0].split()[0]
 
     def _uid_store_deleted(self, client: Any, uid: str, features: _ServerFeatures) -> bool:
-        return self._uid_store_flag(client, uid, "\\Deleted", features)
-
-    def _uid_store_flag(self, client: Any, uid: str, flag: str, features: _ServerFeatures) -> bool:
         # Optimistic path: try UID STORE first because UID is stable and avoids
         # sequence-number lookup. If this fails once for the session, remember it
         # and use the sequence STORE fallback directly for remaining UIDs.
         if features.uid_store is not False:
-            status, _ = client.uid("STORE", uid, "+FLAGS", f"({flag})")
+            status, _ = client.uid("STORE", uid, "+FLAGS", "(\\Deleted)")
             if status == "OK":
                 features.uid_store = True
                 return True
@@ -753,12 +728,12 @@ class EmailChannel(BaseChannel):
         # unreliable: resolve the current sequence number from UID and use STORE.
         imap_id = self._lookup_imap_id_by_uid(client, uid)
         if not imap_id:
-            self.logger.warning("Could not locate UID {} to set flag {}", uid, flag)
+            self.logger.warning("Post-action skipped: UID {} not found", uid)
             return False
 
-        status, _ = client.store(imap_id, "+FLAGS", flag)
+        status, _ = client.store(imap_id, "+FLAGS", "\\Deleted")
         if status != "OK":
-            self.logger.warning("Failed to set flag {} on UID {}", flag, uid)
+            self.logger.warning("Post-action failed: could not mark UID {} as deleted", uid)
             return False
         return True
 
@@ -798,6 +773,16 @@ class EmailChannel(BaseChannel):
                     return bytes(fetched_item[1])
         return None
 
+    @staticmethod
+    def _extract_uid(fetched: list[Any]) -> str:
+        for item in fetched:
+            if isinstance(item, tuple) and item and isinstance(item[0], (bytes, bytearray)):
+                head = bytes(item[0]).decode("utf-8", errors="ignore")
+                m = re.search(r"UID\s+(\d+)", head)
+                if m:
+                    return m.group(1)
+        return ""
+
     @staticmethod
     def _decode_header_value(value: str) -> str:
         if not value:

nanobot/channels/email/tests/test_email_channel.py

@@ -53,7 +53,30 @@ def _make_raw_email(
 def test_fetch_new_messages_parses_unseen_and_marks_seen(monkeypatch) -> None:
     raw = _make_raw_email(subject="Invoice", body="Please pay")
 
-    fake = _make_fake_imap(raw, uid=b"123")
+    class FakeIMAP:
+        def __init__(self) -> None:
+            self.store_calls: list[tuple[bytes, str, str]] = []
+
+        def login(self, _user: str, _pw: str):
+            return "OK", [b"logged in"]
+
+        def select(self, _mailbox: str):
+            return "OK", [b"1"]
+
+        def search(self, *_args):
+            return "OK", [b"1"]
+
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"1 (UID 123 BODY[] {200})", raw), b")"]
+
+        def store(self, imap_id: bytes, op: str, flags: str):
+            self.store_calls.append((imap_id, op, flags))
+            return "OK", [b""]
+
+        def logout(self):
+            return "BYE", [b""]
+
+    fake = FakeIMAP()
     monkeypatch.setattr("nanobot.channels.email.runtime.imaplib.IMAP4_SSL", lambda _h, _p: fake)
 
     channel = EmailChannel(_make_config(), MessageBus())
@@ -63,25 +86,38 @@ def test_fetch_new_messages_parses_unseen_and_marks_seen(monkeypatch) -> None:
     assert items[0]["sender"] == "alice@example.com"
     assert items[0]["subject"] == "Invoice"
     assert "Please pay" in items[0]["content"]
-    assert ("STORE", "123", "+FLAGS", "(\\Seen)") in fake.uid_calls
-    assert [call for call in fake.uid_calls if call[0] == "FETCH"] == [
-        ("FETCH", "123", "(BODY.PEEK[HEADER])"),
-        ("FETCH", "123", "(BODY.PEEK[])"),
-    ]
+    assert fake.store_calls == [(b"1", "+FLAGS", "\\Seen")]
     assert skipped_uids == set()
 
     # Same UID should be deduped in-process.
     items_again, skipped_again = channel._fetch_new_messages()
     assert items_again == []
     assert skipped_again == set()
-    assert len([call for call in fake.uid_calls if call[0] == "FETCH"]) == 2
 
 
 def test_fetch_new_messages_returns_accepted_and_skipped_uids(monkeypatch) -> None:
     raw = _make_raw_email(subject="Invoice", body="Please pay")
 
-    fake = _make_fake_imap(raw, uid=b"123")
-    monkeypatch.setattr("nanobot.channels.email.runtime.imaplib.IMAP4_SSL", lambda _h, _p: fake)
+    class FakeIMAP:
+        def login(self, _user: str, _pw: str):
+            return "OK", [b"logged in"]
+
+        def select(self, _mailbox: str):
+            return "OK", [b"1"]
+
+        def search(self, *_args):
+            return "OK", [b"1"]
+
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"1 (UID 123 BODY[] {200})", raw), b")"]
+
+        def store(self, _imap_id: bytes, _op: str, _flags: str):
+            return "OK", [b""]
+
+        def logout(self):
+            return "BYE", [b""]
+
+    monkeypatch.setattr("nanobot.channels.email.runtime.imaplib.IMAP4_SSL", lambda _h, _p: FakeIMAP())
 
     channel = EmailChannel(_make_config(post_action="delete"), MessageBus())
     items, skipped_uids = channel._fetch_new_messages()
@@ -94,10 +130,26 @@ def test_fetch_new_messages_returns_accepted_and_skipped_uids(monkeypatch) -> No
 def test_fetch_new_messages_rejected_returns_skipped_uid(monkeypatch) -> None:
     raw = _make_raw_email(from_addr="Nanobot <bot@example.com>", subject="Loop test")
 
-    monkeypatch.setattr(
-        "nanobot.channels.email.runtime.imaplib.IMAP4_SSL",
-        lambda _h, _p: _make_fake_imap(raw, uid=b"123"),
-    )
+    class FakeIMAP:
+        def login(self, _user: str, _pw: str):
+            return "OK", [b"logged in"]
+
+        def select(self, _mailbox: str):
+            return "OK", [b"1"]
+
+        def search(self, *_args):
+            return "OK", [b"1"]
+
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"1 (UID 123 BODY[] {200})", raw), b")"]
+
+        def store(self, _imap_id: bytes, _op: str, _flags: str):
+            return "OK", [b""]
+
+        def logout(self):
+            return "BYE", [b""]
+
+    monkeypatch.setattr("nanobot.channels.email.runtime.imaplib.IMAP4_SSL", lambda _h, _p: FakeIMAP())
 
     channel_skip = EmailChannel(
         _make_config(from_address="bot@example.com", post_action="delete", post_action_ignore_skipped=True),
@@ -493,7 +545,30 @@ async def test_start_keeps_post_actions_for_successful_emails_when_later_deliver
 def test_fetch_new_messages_skips_self_sent_email_and_marks_seen(monkeypatch) -> None:
     raw = _make_raw_email(from_addr="Nanobot <bot@example.com>", subject="Loop test")
 
-    fake = _make_fake_imap(raw, uid=b"123")
+    class FakeIMAP:
+        def __init__(self) -> None:
+            self.store_calls: list[tuple[bytes, str, str]] = []
+
+        def login(self, _user: str, _pw: str):
+            return "OK", [b"logged in"]
+
+        def select(self, _mailbox: str):
+            return "OK", [b"1"]
+
+        def search(self, *_args):
+            return "OK", [b"1"]
+
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"1 (UID 123 BODY[] {200})", raw), b")"]
+
+        def store(self, imap_id: bytes, op: str, flags: str):
+            self.store_calls.append((imap_id, op, flags))
+            return "OK", [b""]
+
+        def logout(self):
+            return "BYE", [b""]
+
+    fake = FakeIMAP()
     monkeypatch.setattr("nanobot.channels.email.runtime.imaplib.IMAP4_SSL", lambda _h, _p: fake)
 
     channel = EmailChannel(_make_config(from_address="bot@example.com"), MessageBus())
@@ -501,7 +576,7 @@ def test_fetch_new_messages_skips_self_sent_email_and_marks_seen(monkeypatch) ->
 
     assert items == []
     assert skipped_uids == {"123"}
-    assert ("STORE", "123", "+FLAGS", "(\\Seen)") in fake.uid_calls
+    assert fake.store_calls == [(b"1", "+FLAGS", "\\Seen")]
 
     # Same UID should still be deduped after being ignored.
     items_again, skipped_again = channel._fetch_new_messages()
@@ -539,14 +614,37 @@ def test_fetch_new_messages_skips_self_sent_across_identity_sources(
     imap_username matches, and must be case-insensitive."""
     raw = _make_raw_email(from_addr=from_header, subject="Loop test")
 
-    fake = _make_fake_imap(raw, uid=b"123")
+    class FakeIMAP:
+        def __init__(self) -> None:
+            self.store_calls: list[tuple[bytes, str, str]] = []
+
+        def login(self, _user: str, _pw: str):
+            return "OK", [b"logged in"]
+
+        def select(self, _mailbox: str):
+            return "OK", [b"1"]
+
+        def search(self, *_args):
+            return "OK", [b"1"]
+
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"1 (UID 123 BODY[] {200})", raw), b")"]
+
+        def store(self, imap_id: bytes, op: str, flags: str):
+            self.store_calls.append((imap_id, op, flags))
+            return "OK", [b""]
+
+        def logout(self):
+            return "BYE", [b""]
+
+    fake = FakeIMAP()
     monkeypatch.setattr("nanobot.channels.email.runtime.imaplib.IMAP4_SSL", lambda _h, _p: fake)
 
     channel = EmailChannel(_make_config(**config_override), MessageBus())
     items, _ = channel._fetch_new_messages()
 
     assert items == []
-    assert ("STORE", "123", "+FLAGS", "(\\Seen)") in fake.uid_calls
+    assert fake.store_calls == [(b"1", "+FLAGS", "\\Seen")]
 
 
 def test_fetch_new_messages_retries_once_when_imap_connection_goes_stale(monkeypatch) -> None:
@@ -564,16 +662,15 @@ def test_fetch_new_messages_retries_once_when_imap_connection_goes_stale(monkeyp
         def select(self, _mailbox: str):
             return "OK", [b"1"]
 
-        def uid(self, command: str, *args):
-            if command == "SEARCH":
-                self.search_calls += 1
-                if fail_once["pending"]:
-                    fail_once["pending"] = False
-                    raise imaplib.IMAP4.abort("socket error")
-                return "OK", [b"123"]
-            if command == "FETCH":
-                return "OK", [(b"1 (UID 123 BODY[] {200})", raw), b")"]
-            return "OK", [b""]
+        def search(self, *_args):
+            self.search_calls += 1
+            if fail_once["pending"]:
+                fail_once["pending"] = False
+                raise imaplib.IMAP4.abort("socket error")
+            return "OK", [b"1"]
+
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"1 (UID 123 BODY[] {200})", raw), b")"]
 
         def store(self, imap_id: bytes, op: str, flags: str):
             self.store_calls.append((imap_id, op, flags))
@@ -603,7 +700,10 @@ def test_fetch_new_messages_retries_once_when_imap_connection_goes_stale(monkeyp
 def test_fetch_new_messages_keeps_messages_collected_before_stale_retry(monkeypatch) -> None:
     raw_first = _make_raw_email(subject="First", body="First body")
     raw_second = _make_raw_email(subject="Second", body="Second body")
-    mailbox_state = {"123": raw_first, "124": raw_second}
+    mailbox_state = {
+        b"1": {"uid": b"123", "raw": raw_first, "seen": False},
+        b"2": {"uid": b"124", "raw": raw_second, "seen": False},
+    }
     fail_once = {"pending": True}
 
     class FlakyIMAP:
@@ -613,18 +713,20 @@ def test_fetch_new_messages_keeps_messages_collected_before_stale_retry(monkeypa
         def select(self, _mailbox: str):
             return "OK", [b"2"]
 
-        def uid(self, command: str, *args):
-            if command == "SEARCH":
-                keys = " ".join(sorted(mailbox_state.keys(), key=int))
-                return "OK", [keys.encode()]
-            if command == "FETCH":
-                uid = args[0]
-                if uid == "124" and fail_once["pending"]:
-                    fail_once["pending"] = False
-                    raise imaplib.IMAP4.abort("socket error")
-                raw = mailbox_state[uid]
-                header = f"{uid} (UID {uid} BODY[] {{200}})".encode()
-                return "OK", [(header, raw), b")"]
+        def search(self, *_args):
+            unseen_ids = [imap_id for imap_id, item in mailbox_state.items() if not item["seen"]]
+            return "OK", [b" ".join(unseen_ids)]
+
+        def fetch(self, imap_id: bytes, _parts: str):
+            if imap_id == b"2" and fail_once["pending"]:
+                fail_once["pending"] = False
+                raise imaplib.IMAP4.abort("socket error")
+            item = mailbox_state[imap_id]
+            header = b"%s (UID %s BODY[] {200})" % (imap_id, item["uid"])
+            return "OK", [(header, item["raw"]), b")"]
+
+        def store(self, imap_id: bytes, _op: str, _flags: str):
+            mailbox_state[imap_id]["seen"] = True
             return "OK", [b""]
 
         def logout(self):
@@ -942,13 +1044,12 @@ def test_fetch_messages_between_dates_uses_imap_since_before_without_mark_seen(m
         def select(self, _mailbox: str):
             return "OK", [b"1"]
 
-        def uid(self, command: str, *args):
-            if command == "SEARCH":
-                self.search_args = args
-                return "OK", [b"999"]
-            if command == "FETCH":
-                return "OK", [(b"5 (UID 999 BODY[] {200})", raw), b")"]
-            return "OK", [b""]
+        def search(self, *_args):
+            self.search_args = _args
+            return "OK", [b"5"]
+
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"5 (UID 999 BODY[] {200})", raw), b")"]
 
         def store(self, imap_id: bytes, op: str, flags: str):
             self.store_calls.append((imap_id, op, flags))
@@ -969,7 +1070,7 @@ def test_fetch_messages_between_dates_uses_imap_since_before_without_mark_seen(m
 
     assert len(items) == 1
     assert items[0]["subject"] == "Status"
-    # uid("SEARCH", None, "SINCE", "06-Feb-2026", "BEFORE", "07-Feb-2026")
+    # search(None, "SINCE", "06-Feb-2026", "BEFORE", "07-Feb-2026")
     assert fake.search_args is not None
     assert fake.search_args[1:] == ("SINCE", "06-Feb-2026", "BEFORE", "07-Feb-2026")
     assert fake.store_calls == []
@@ -979,12 +1080,11 @@ def test_fetch_messages_between_dates_uses_imap_since_before_without_mark_seen(m
 # Security: Anti-spoofing tests for Authentication-Results verification
 # ---------------------------------------------------------------------------
 
-def _make_fake_imap(raw: bytes, uid: bytes = b"500"):
+def _make_fake_imap(raw: bytes):
     """Return a FakeIMAP class pre-loaded with the given raw email."""
     class FakeIMAP:
         def __init__(self) -> None:
             self.store_calls: list[tuple[bytes, str, str]] = []
-            self.uid_calls: list[tuple] = []
 
         def login(self, _user: str, _pw: str):
             return "OK", [b"logged in"]
@@ -992,16 +1092,11 @@ def _make_fake_imap(raw: bytes, uid: bytes = b"500"):
         def select(self, _mailbox: str):
             return "OK", [b"1"]
 
-        def capability(self):
-            return "OK", [b"IMAP4rev1"]
+        def search(self, *_args):
+            return "OK", [b"1"]
 
-        def uid(self, command: str, *args):
-            self.uid_calls.append((command, *args))
-            if command == "SEARCH":
-                return "OK", [uid]
-            if command == "FETCH":
-                return "OK", [(b"1 (UID " + uid + b" BODY[] {200})", raw), b")"]
-            return "OK", [b""]
+        def fetch(self, _imap_id: bytes, _parts: str):
+            return "OK", [(b"1 (UID 500 BODY[] {200})", raw), b")"]
 
         def store(self, imap_id: bytes, op: str, flags: str):
             self.store_calls.append((imap_id, op, flags))
@@ -1197,10 +1292,7 @@ def test_fetch_new_messages_ignores_unauthorized_sender_before_attachments(monke
 
     assert channel._fetch_new_messages() == ([], {"500"})
     assert called["attachments"] is False
-    assert [call for call in fake.uid_calls if call[0] == "FETCH"] == [
-        ("FETCH", "500", "(BODY.PEEK[HEADER])")
-    ]
-    assert ("STORE", "500", "+FLAGS", "(\\Seen)") in fake.uid_calls
+    assert fake.store_calls == [(b"1", "+FLAGS", "\\Seen")]
 
 
 def test_extract_attachments_saves_pdf(tmp_path, monkeypatch) -> None:

nanobot/channels/telegram/runtime.py

@@ -897,68 +897,6 @@ class TelegramChannel(BaseChannel):
             self.logger.debug("sendRichMessage failed: {}", exc)
             return False
 
-    async def _try_edit_rich(self, chat_id: int, message_id: int, content: str) -> bool:
-        """Upgrade an existing message to rich in place via editMessageText (Bot API 10.1).
-
-        Editing in place keeps the message identity, so the streaming preview is
-        upgraded without the delete-and-resend pattern that caused flickering and
-        dropped line breaks (issue #4470).
-
-        Returns True when the rich edit is in place (including the ambiguous
-        "message is not modified" retry outcome after a response timeout).
-        Returns False only when the legacy HTML path should take over:
-        capability errors (server older than Bot API 10.1, which also trip the
-        rich latch) and content-shaped BadRequest rejections. Transport,
-        rate-limit, and unexpected errors propagate so the final-edit retry
-        contract is preserved — ChannelManager retries the buffered send
-        instead of an immediate legacy edit doubling connection demand.
-        """
-        if not self._app:
-            return False
-
-        payload: dict[str, Any] = {
-            "chat_id": chat_id,
-            "message_id": message_id,
-            "rich_message": {
-                "markdown": content,
-            },
-        }
-        try:
-            await self._call_with_retry(
-                self._app.bot.do_api_request,
-                "editMessageText",
-                api_kwargs=payload,
-            )
-            return True
-        except BadRequest as exc:
-            if self._is_not_modified_error(exc):
-                # Ambiguous success: the rich edit was applied server-side but
-                # its response timed out, so the retry hit "message is not
-                # modified". Treat it as done rather than letting the legacy
-                # edit overwrite the already-successful rich result.
-                self.logger.debug("Rich stream edit already applied for {}", chat_id)
-                return True
-            # Before Bot API 10.1, editMessageText ignores rich_message and
-            # reports the absent text argument instead.
-            pre_rich_edit_server = (
-                bool(content)
-                and str(exc).strip().lower() == "message text is empty"
-            )
-            if self._is_rich_capability_error(exc) or pre_rich_edit_server:
-                self.logger.debug("editMessageText rich_message not available, disabling")
-                self._rich_send_disabled = True
-                return False
-            # Content-shaped rejections (invalid markdown, unsupported media in
-            # the rich payload, …) fall back to the legacy HTML edit.
-            self.logger.debug("editMessageText rich_message rejected: {}", exc)
-            return False
-        except Exception:
-            # Transport, rate-limit, and unexpected errors propagate so the
-            # final-edit retry contract stays intact: ChannelManager retries
-            # the buffered send instead of this handler doubling connection
-            # demand with an immediate legacy edit.
-            raise
-
     async def send(self, msg: OutboundMessage) -> None:
         """Send a message through Telegram."""
         app = await self._wait_for_app()
@@ -1198,16 +1136,26 @@ class TelegramChannel(BaseChannel):
                 thread_kwargs["message_thread_id"] = message_thread_id
             raw_text = buf.text
 
-            # Try upgrading the streaming preview to rich in place (Bot API 10.1:
-            # editMessageText gained a rich_message parameter). Editing in place
-            # keeps the message identity, so there is no delete-and-resend and
-            # none of the flickering / dropped line breaks from issue #4470.
-            # The previous branch here was unreachable: it was guarded by
-            # ``not buf.message_id`` after an early return had already ensured
-            # ``buf.message_id`` is set (issue #5516).
-            if self.config.rich_messages and not getattr(self, "_rich_send_disabled", False):
-                rich_ok = await self._try_edit_rich(int_chat_id, buf.message_id, raw_text)
+            # Try sendRichMessage for final output (Bot API 10.1).
+            # Skip when a streaming preview already exists to avoid the
+            # delete-and-resend pattern that causes flickering and drops
+            # line breaks (issue #4470).
+            if not buf.message_id and self.config.rich_messages and not getattr(self, "_rich_send_disabled", False):
+                reply_params = None
+                if reply_to_message_id := meta.get("message_id"):
+                    reply_params = {"message_id": int(reply_to_message_id), "allow_sending_without_reply": True}
+                rich_ok = await self._try_send_rich(
+                    int_chat_id, raw_text, reply_params, thread_kwargs, None,
+                )
                 if rich_ok:
+                    # Delete the streaming preview message
+                    try:
+                        await self._call_with_retry(
+                            app.bot.delete_message,
+                            chat_id=int_chat_id, message_id=buf.message_id,
+                        )
+                    except Exception:
+                        pass  # Preview stays if delete fails
                     self._stream_bufs.pop(chat_id, None)
                     return
 

nanobot/channels/telegram/tests/test_telegram_channel.py

@@ -2735,130 +2735,3 @@ def test_markdown_to_html_code_block_same_line_no_newline() -> None:
 
     stripped = _strip_md_block(text)
     assert stripped == "Use <tag> here"
-
-
-@pytest.mark.asyncio
-async def test_send_delta_stream_end_upgrades_preview_to_rich_in_place() -> None:
-    """Rich messages finally work with streaming: the preview is upgraded via
-    editMessageText rich_message (in place), not delete-and-resend (issue #5516)."""
-    from telegram.error import BadRequest
-
-    channel = TelegramChannel(
-        TelegramConfig(enabled=True, token="123:abc", allow_from=["*"], rich_messages=True),
-        MessageBus(),
-    )
-    _install_ready_app(channel)
-    channel._app.bot.do_api_request = AsyncMock()
-    channel._app.bot.edit_message_text = AsyncMock(side_effect=BadRequest("should not be reached"))
-    channel._stream_bufs["123"] = _StreamBuf(text="**hello**", message_id=7, last_edit=0.0)
-
-    await channel.send_delta("123", "", stream_end=True)
-
-    # editMessageText with rich_message payload, in place (same message_id)
-    channel._app.bot.do_api_request.assert_awaited_once()
-    args, kwargs = channel._app.bot.do_api_request.await_args
-    assert args[0] == "editMessageText"
-    assert kwargs["api_kwargs"]["chat_id"] == 123
-    assert kwargs["api_kwargs"]["message_id"] == 7
-    assert kwargs["api_kwargs"]["rich_message"] == {"markdown": "**hello**"}
-    # No delete-and-resend, no legacy HTML edit
-    channel._app.bot.edit_message_text.assert_not_awaited()
-    assert "123" not in channel._stream_bufs
-
-
-@pytest.mark.asyncio
-async def test_send_delta_stream_end_rich_capability_error_latches_and_falls_back() -> None:
-    """On a pre-10.1 Bot API server the rich edit fails, the latch trips, and the
-    legacy HTML edit handles the final output."""
-    from telegram.error import BadRequest
-
-    channel = TelegramChannel(
-        TelegramConfig(enabled=True, token="123:abc", allow_from=["*"], rich_messages=True),
-        MessageBus(),
-    )
-    _install_ready_app(channel)
-    # Before Bot API 10.1, editMessageText ignores rich_message and requires text.
-    channel._app.bot.do_api_request = AsyncMock(
-        side_effect=BadRequest("Message text is empty")
-    )
-    channel._app.bot.edit_message_text = AsyncMock()
-    channel._stream_bufs["123"] = _StreamBuf(text="hello", message_id=7, last_edit=0.0)
-
-    await channel.send_delta("123", "", stream_end=True)
-
-    channel._app.bot.do_api_request.assert_awaited_once()
-    # Latch tripped: subsequent sends skip the rich path entirely
-    assert channel._rich_send_disabled is True
-    # Legacy HTML edit handled the final message
-    channel._app.bot.edit_message_text.assert_awaited_once()
-    assert "123" not in channel._stream_bufs
-
-
-@pytest.mark.asyncio
-async def test_send_delta_stream_end_rich_disabled_uses_legacy_html() -> None:
-    """rich_messages=False (the default) keeps the legacy HTML path untouched."""
-    channel = TelegramChannel(
-        TelegramConfig(enabled=True, token="123:abc", allow_from=["*"]),
-        MessageBus(),
-    )
-    _install_ready_app(channel)
-    channel._app.bot.do_api_request = AsyncMock()
-    channel._app.bot.edit_message_text = AsyncMock()
-    channel._stream_bufs["123"] = _StreamBuf(text="hello", message_id=7, last_edit=0.0)
-
-    await channel.send_delta("123", "", stream_end=True)
-
-    channel._app.bot.do_api_request.assert_not_called()
-    channel._app.bot.edit_message_text.assert_awaited_once()
-    assert "123" not in channel._stream_bufs
-
-
-@pytest.mark.asyncio
-async def test_send_delta_stream_end_rich_network_error_propagates_for_retry() -> None:
-    """A transport failure on the rich edit must propagate so ChannelManager
-    retries the buffered send — not fall through to an immediate legacy edit
-    that doubles connection demand during pool exhaustion."""
-    from telegram.error import NetworkError
-
-    channel = TelegramChannel(
-        TelegramConfig(enabled=True, token="123:abc", allow_from=["*"], rich_messages=True),
-        MessageBus(),
-    )
-    _install_ready_app(channel)
-    channel._app.bot.do_api_request = AsyncMock(side_effect=NetworkError("pool exhausted"))
-    channel._app.bot.edit_message_text = AsyncMock()
-    channel._stream_bufs["123"] = _StreamBuf(text="hello", message_id=7, last_edit=0.0)
-
-    with pytest.raises(NetworkError):
-        await channel.send_delta("123", "", stream_end=True)
-
-    # No legacy fallback edit: the buffered state stays for the manager retry.
-    channel._app.bot.edit_message_text.assert_not_awaited()
-    assert "123" in channel._stream_bufs
-
-
-@pytest.mark.asyncio
-async def test_send_delta_stream_end_rich_not_modified_after_timeout_is_success() -> None:
-    """Ambiguous success: the rich edit applied server-side but its response
-    timed out, so the retry hit "message is not modified". That is a completed
-    rich upgrade — the legacy edit must not overwrite it."""
-    from telegram.error import BadRequest, TimedOut
-
-    channel = TelegramChannel(
-        TelegramConfig(enabled=True, token="123:abc", allow_from=["*"], rich_messages=True),
-        MessageBus(),
-    )
-    _install_ready_app(channel)
-    # First attempt (inside _call_with_retry) times out, retry reports the
-    # edit as already applied.
-    channel._app.bot.do_api_request = AsyncMock(
-        side_effect=[TimedOut(), BadRequest("Message is not modified")]
-    )
-    channel._app.bot.edit_message_text = AsyncMock(side_effect=AssertionError("must not overwrite rich result"))
-    channel._stream_bufs["123"] = _StreamBuf(text="hello", message_id=7, last_edit=0.0)
-
-    await channel.send_delta("123", "", stream_end=True)
-
-    assert channel._app.bot.do_api_request.await_count == 2
-    channel._app.bot.edit_message_text.assert_not_awaited()
-    assert "123" not in channel._stream_bufs

nanobot/channels/websocket/runtime.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-import errno
 import ipaddress
 import json
 import socket
@@ -539,32 +538,14 @@ class WebSocketChannel(BaseChannel):
     # -- Server lifecycle and connection ingress ---------------------------
 
     @staticmethod
-    def _socket_is_accepting(sock: socket.socket) -> bool:
-        """Return whether a bound socket still advertises a listen capability.
-
-        ``SO_ACCEPTCONN`` is not portable: macOS/BSD raise ``OSError`` with
-        ``ENOPROTOOPT`` ("Protocol not available") for this option even on a
-        perfectly healthy listening socket. Treating that as "not serving"
-        makes the listener look permanently degraded, so the caller retries
-        forever and the channel never reaches a ready state. When the option
-        is unavailable we fall back to the file-descriptor liveness check.
-        """
-        if sock.fileno() < 0:
-            return False
-        try:
-            return bool(sock.getsockopt(socket.SOL_SOCKET, socket.SO_ACCEPTCONN))
-        except OSError as exc:
-            if exc.errno in (errno.ENOPROTOOPT, errno.EOPNOTSUPP):
-                return True
-            raise
-
-    @classmethod
-    def _listener_is_serving(cls, server: Server) -> bool:
+    def _listener_is_serving(server: Server) -> bool:
         """Return whether every bound socket still has a live listen capability."""
         try:
             sockets = server.sockets
             return bool(sockets) and server.is_serving() and all(
-                cls._socket_is_accepting(sock) for sock in sockets
+                sock.fileno() >= 0
+                and bool(sock.getsockopt(socket.SOL_SOCKET, socket.SO_ACCEPTCONN))
+                for sock in sockets
             )
         except OSError:
             return False

nanobot/channels/websocket/tests/test_websocket_http_routes.py

@@ -2333,48 +2333,6 @@ async def test_session_delete_removes_transcript_without_canonical_file(
         await server_task
 
 
-@pytest.mark.asyncio
-async def test_session_delete_removes_unpersisted_new_chat(
-    bus: MagicMock, tmp_path: Path
-) -> None:
-    sm = SessionManager(tmp_path / "sessions")
-    project = tmp_path / "project"
-    project.mkdir()
-    channel = _ch(bus, session_manager=sm, workspace_path=tmp_path, port=_free_port())
-    connection = AsyncMock()
-    connection.remote_address = ("127.0.0.1", 50123)
-
-    await channel._dispatch_envelope(
-        connection,
-        "webui-client",
-        {
-            "type": "new_chat",
-            "workspace_scope": {
-                "project_path": str(project),
-                "access_mode": "full",
-            },
-        },
-    )
-
-    attached = next(
-        payload
-        for payload in (
-            json.loads(call.args[0]) for call in connection.send.await_args_list
-        )
-        if payload.get("event") == "attached"
-    )
-    key = f"websocket:{attached['chat_id']}"
-
-    assert sm.list_sessions() == []
-    assert channel.gateway.workspaces.scope_for_session_key(key).project_path == project.resolve()
-
-    response = await _webui_mutate(channel, "session.delete", {"key": key})
-
-    assert response.status_code == 200
-    assert response.json()["deleted"] is True
-    assert channel.gateway.workspaces.scope_for_session_key(key).project_path == tmp_path.resolve()
-
-
 @pytest.mark.asyncio
 async def test_webui_automations_route_lists_all_jobs_and_allows_user_actions(
     bus: MagicMock, tmp_path: Path

nanobot/cli/commands.py

@@ -87,12 +87,7 @@ app = typer.Typer(
     name="nanobot",
     context_settings={"help_option_names": ["-h", "--help"]},
     help=f"{__logo__} nanobot - Personal AI Assistant",
-    epilog=(
-        "Run `nanobot` without a subcommand to start the terminal agent. "
-        "Use `nanobot agent --help` for agent options."
-    ),
-    invoke_without_command=True,
-    no_args_is_help=False,
+    no_args_is_help=True,
 )
 
 console = Console()
@@ -103,7 +98,7 @@ def version_callback(value: bool):
         raise typer.Exit()
 
 
-@app.callback(invoke_without_command=True)
+@app.callback()
 def main(
     ctx: typer.Context,
     version: bool = typer.Option(
@@ -115,11 +110,7 @@ def main(
     # imports this Typer app directly instead of ``nanobot.cli.entry``. Keep the
     # role identity correct until that launcher is regenerated.
     command = ctx.invoked_subcommand
-    set_cli_process_identity([command] if command else ["agent"])
-    if command is None:
-        from nanobot.cli.entry import _run_agent
-
-        _run_agent([], prog_name="nanobot")
+    set_cli_process_identity([command] if command else sys.argv[1:])
 
 
 # ============================================================================

nanobot/cli/entry.py

@@ -8,28 +8,6 @@ from contextlib import suppress
 
 from nanobot.cli.process_identity import set_cli_process_identity
 
-_ROOT_OPTIONS = frozenset(
-    {
-        "-h",
-        "--help",
-        "-v",
-        "--version",
-        "--install-completion",
-        "--show-completion",
-    }
-)
-
-
-def _agent_invocation_args(args: list[str]) -> list[str] | None:
-    """Return agent arguments when the root command should act as ``agent``."""
-    if not args:
-        return []
-    if args[0] == "agent":
-        return args[1:]
-    if args[0].startswith("-") and args[0].split("=", 1)[0] not in _ROOT_OPTIONS:
-        return args
-    return None
-
 
 def _native_tui_candidate(args: list[str]) -> bool:
     """Return whether ``agent`` can start without the classic agent stack."""
@@ -56,35 +34,19 @@ def _configure_windows_console() -> None:
                 reconfigure(encoding="utf-8", errors="replace")
 
 
-def _run_agent(args: list[str], *, prog_name: str) -> None:
-    """Run the shared agent command without importing the complete CLI graph."""
-    import typer
-
-    from nanobot.cli.agent import agent
-
-    agent_app = typer.Typer(add_completion=False)
-    agent_app.command()(agent)
-    command = typer.main.get_command(agent_app)
-    command.main(args=args, prog_name=prog_name)
-
-
 def main() -> None:
     """Dispatch native TUI startup without importing the complete CLI graph."""
-    raw_args = sys.argv[1:]
-    # Installed completion scripts call ``nanobot`` without positional arguments
-    # and pass the request through this environment variable. Keep those requests
-    # on the root command so subcommands remain discoverable.
-    shell_completion = bool(os.environ.get("_NANOBOT_COMPLETE"))
-    agent_args = None if shell_completion else _agent_invocation_args(raw_args)
-    dispatch_args = ["agent", *agent_args] if agent_args is not None else raw_args
-    set_cli_process_identity(dispatch_args)
+    set_cli_process_identity(sys.argv[1:])
     _configure_windows_console()
-    root_agent_alias = agent_args is not None and raw_args[:1] != ["agent"]
-    if agent_args is not None and (
-        root_agent_alias or _native_tui_candidate(dispatch_args)
-    ):
-        prog_name = "nanobot" if root_agent_alias else "nanobot agent"
-        _run_agent(agent_args, prog_name=prog_name)
+    if _native_tui_candidate(sys.argv[1:]):
+        import typer
+
+        from nanobot.cli.agent import agent
+
+        fast_app = typer.Typer(add_completion=False)
+        fast_app.command()(agent)
+        command = typer.main.get_command(fast_app)
+        command.main(args=sys.argv[2:], prog_name="nanobot agent")
         return
 
     from nanobot.cli.commands import app

nanobot/cli/gateway_runtime.py

@@ -662,6 +662,11 @@ def _run_gateway(
                 if isinstance(message_tool, MessageTool) and suppress_token is not None:
                     message_tool.reset_suppress_delivery(suppress_token)
 
+            # Keep a small tail of heartbeat history so the loop stays bounded.
+            session = agent.sessions.get_or_create("heartbeat")
+            session.retain_recent_legal_suffix(hb_cfg.keep_recent_messages)
+            agent.sessions.save(session)
+
             if not resp or not resp.content:
                 return
 

nanobot/cli/provider.py

@@ -29,7 +29,7 @@ _PROVIDER_DISPLAY: dict[str, str] = {
 
 _OAUTH_PROVIDER_DEFAULT_MODELS: dict[str, str] = {
     "openai_codex": "openai-codex/gpt-5.6-sol",
-    "xai_grok": "xai-grok/grok-4.6",
+    "xai_grok": "xai-grok/grok-4.5",
     "github_copilot": "github-copilot/gpt-5.4-mini",
 }
 
@@ -134,10 +134,7 @@ def _set_oauth_provider_as_main(
     config.agents.defaults.model_preset = None
     config.agents.defaults.provider = provider_name
     config.agents.defaults.model = selected_model
-    if provider_name == "xai_grok" and selected_model in {
-        "xai-grok/grok-4.5",
-        "xai-grok/grok-4.6",
-    }:
+    if provider_name == "xai_grok" and selected_model == "xai-grok/grok-4.5":
         config.agents.defaults.context_window_tokens = 500_000
     save_config(config, resolved_config_path)
 

nanobot/cli/tui_launcher.py

@@ -21,7 +21,6 @@ from nanobot.cli.process_identity import named_executable
 from nanobot.cli.runtime_config import _model_display
 from nanobot.cli.webui_support import (
     _gateway_health_ready,
-    _gateway_health_url,
     _gateway_instance_command,
     _host_for_local_browser,
     _webui_endpoint_reachable,
@@ -97,10 +96,6 @@ def launch_tui(
         env.update(
             {
                 "NANOBOT_TUI_BOOTSTRAP_URL": f"{base_url}/webui/bootstrap",
-                "NANOBOT_TUI_HEALTH_URL": _gateway_health_url(
-                    config.gateway.host,
-                    config.gateway.port,
-                ),
                 "NANOBOT_TUI_API_URL": base_url,
                 "NANOBOT_TUI_MODEL": _model_display(config)[0],
                 "NANOBOT_TUI_MODEL_PRESET": config.agents.defaults.model_preset or "default",

nanobot/cli/webui_support.py

@@ -1,14 +1,12 @@
 """Shared WebUI setup, URL, health, and browser helpers."""
 
-import os
 import subprocess
 import sys
 import time
 import webbrowser
 from collections.abc import Callable
-from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, BinaryIO
+from typing import TYPE_CHECKING, Any
 
 import typer
 from pydantic import ValidationError
@@ -459,104 +457,27 @@ def _print_webui_foreground_lifecycle(*, attached: bool) -> None:
         console.print("[green]WebUI is attached to the shared gateway.[/green]")
     console.print("[dim]Closing the browser does not stop channels or automations.[/dim]")
     console.print(
-        "[dim]Following live gateway logs. Press Ctrl+C to detach; the gateway stops "
-        "only when the last local client exits.[/dim]"
+        "[dim]Press Ctrl+C to detach; the gateway stops only when the last local client exits.[/dim]"
     )
 
 
-_LOG_ANCHOR_BYTES = 64
-
-
-@dataclass
-class _GatewayLogCursor:
-    offset: int = 0
-    identity: tuple[int, int] | None = None
-    anchor: bytes = b""
-    pending: bytes = b""
-
-
-def _log_anchor(handle: BinaryIO, offset: int) -> bytes:
-    size = min(offset, _LOG_ANCHOR_BYTES)
-    handle.seek(offset - size)
-    return handle.read(size)
-
-
-def _start_gateway_log_cursor(log_path: Path) -> _GatewayLogCursor:
-    """Start following at the current end of *log_path*."""
-    try:
-        with log_path.open("rb") as handle:
-            stat = os.fstat(handle.fileno())
-            offset = stat.st_size
-            return _GatewayLogCursor(
-                offset=offset,
-                identity=(stat.st_dev, stat.st_ino),
-                anchor=_log_anchor(handle, offset),
-            )
-    except OSError:
-        return _GatewayLogCursor()
-
-
-def _read_new_gateway_logs(
-    log_path: Path,
-    cursor: _GatewayLogCursor,
-    *,
-    flush: bool = False,
-) -> list[str]:
-    """Read complete gateway log lines appended after *cursor*."""
-    try:
-        with log_path.open("rb") as handle:
-            stat = os.fstat(handle.fileno())
-            identity = (stat.st_dev, stat.st_ino)
-            reset = cursor.identity != identity or stat.st_size < cursor.offset
-            if not reset and cursor.offset:
-                reset = _log_anchor(handle, cursor.offset) != cursor.anchor
-            if reset:
-                cursor.offset = 0
-                cursor.pending = b""
-
-            handle.seek(cursor.offset)
-            chunk = handle.read()
-            cursor.offset = handle.tell()
-            cursor.identity = identity
-            cursor.anchor = _log_anchor(handle, cursor.offset)
-    except OSError:
-        return []
-
-    parts = (cursor.pending + chunk).split(b"\n")
-    cursor.pending = parts.pop()
-    if flush and cursor.pending:
-        parts.append(cursor.pending)
-        cursor.pending = b""
-    return [part.removesuffix(b"\r").decode("utf-8", errors="replace") for part in parts]
-
-
 def _attach_to_background_gateway(
     runtime: "GatewayRuntime",
     *,
     poll_hook: Callable[[], None] | None = None,
     sleep: Callable[[float], None] = time.sleep,
 ) -> None:
-    """Keep the launcher attached and mirror this gateway's new log output."""
-    status = runtime.status()
-    log_path = status.log_path
-    cursor = _start_gateway_log_cursor(log_path)
+    """Keep a WebUI launcher attached without taking ownership of the gateway."""
     _print_webui_foreground_lifecycle(attached=True)
     try:
-        while status.running:
-            for line in _read_new_gateway_logs(log_path, cursor):
-                console.print(line, markup=False, highlight=False)
+        while runtime.status().running:
             if poll_hook is not None:
                 poll_hook()
             sleep(0.5)
-            status = runtime.status()
     except KeyboardInterrupt:
-        for line in _read_new_gateway_logs(log_path, cursor, flush=True):
-            console.print(line, markup=False, highlight=False)
         console.print("\n[yellow]WebUI launcher detached.[/yellow]")
         return
 
-    for line in _read_new_gateway_logs(log_path, cursor, flush=True):
-        console.print(line, markup=False, highlight=False)
     console.print("[yellow]Gateway stopped.[/yellow]")
 
 

nanobot/command/builtin.py

@@ -311,7 +311,7 @@ async def cmd_new(ctx: CommandContext) -> OutboundMessage:
     snapshot = list(session.messages)
     archive_snapshot = None
     runtime = None
-    if session.last_archived < len(snapshot):
+    if session.last_consolidated < len(snapshot):
         runtime = ctx.runtime or loop.runtime_for_session(session)
         archive_snapshot = replace(
             session,

nanobot/config/schema.py

@@ -128,7 +128,7 @@ class AgentDefaults(Base):
     temperature: float = 0.1
     fallback_models: list[FallbackCandidate] = Field(default_factory=list)
     max_tool_iterations: int = 200
-    max_concurrent_subagents: int = Field(default=4, ge=1)
+    max_concurrent_subagents: int = Field(default=1, ge=1)
     max_tool_result_chars: int = 16_000
     provider_retry_mode: Literal["standard", "persistent"] = "standard"
     tool_hint_max_length: int = Field(
@@ -155,6 +155,13 @@ class AgentDefaults(Base):
         default=60,
         ge=0,
     )  # Minimum interval in seconds between scans for idle sessions
+    consolidation_ratio: float = Field(
+        default=0.5,
+        ge=0.1,
+        le=0.95,
+        validation_alias=AliasChoices("consolidationRatio"),
+        serialization_alias="consolidationRatio",
+    )  # Consolidation target ratio (0.5 = 50% of budget retained after compression)
     dream: DreamConfig = Field(default_factory=DreamConfig)
 
     @model_validator(mode="before")
@@ -329,6 +336,7 @@ class HeartbeatConfig(Base):
 
     enabled: bool = True
     interval_s: int = 30 * 60  # 30 minutes
+    keep_recent_messages: int = 8
 
 
 class ApiConfig(Base):

nanobot/cron/service.py

@@ -25,7 +25,6 @@ from nanobot.cron.types import (
     CronSchedule,
     CronStore,
 )
-from nanobot.runtime_context import RUNTIME_CONTEXT_INPUT_META
 from nanobot.utils.run_records import (
     write_run_record as write_automation_run_record,
 )
@@ -116,21 +115,8 @@ def _disable_malformed_legacy_job(job: CronJob) -> None:
     logger.warning("Cron: disabled malformed legacy job '{}' ({}): {}", job.name, job.id, reason)
 
 
-def _persistable_origin_metadata(metadata: dict[str, Any]) -> dict[str, Any]:
-    """Return a detached JSON-safe routing snapshot for a cron payload."""
-    snapshot: dict[str, Any] = {}
-    for key, value in metadata.items():
-        if key == RUNTIME_CONTEXT_INPUT_META:
-            continue
-        try:
-            snapshot[key] = json.loads(json.dumps(value, ensure_ascii=False, allow_nan=False))
-        except (TypeError, ValueError, RecursionError):
-            continue
-    return snapshot
-
-
 def _normalize_agent_turn_job(job: CronJob) -> bool:
-    """Make routing metadata persistable and migrate legacy user cron payloads.
+    """Migrate legacy user cron payloads into session-bound payloads.
 
     Pre-bound user cron jobs stored their delivery target in ``channel``/``to``.
     Normal user-created legacy jobs always have those fields; if they are
@@ -138,12 +124,8 @@ def _normalize_agent_turn_job(job: CronJob) -> bool:
     a runtime legacy execution path.
     """
     payload = job.payload
-    origin_metadata = _persistable_origin_metadata(payload.origin_metadata)
-    changed = origin_metadata != payload.origin_metadata
-    payload.origin_metadata = origin_metadata
-
     if payload.kind != "agent_turn" or not _has_legacy_delivery_context(payload):
-        return changed
+        return False
 
     if not payload.channel or not payload.to:
         _disable_malformed_legacy_job(job)
@@ -153,7 +135,7 @@ def _normalize_agent_turn_job(job: CronJob) -> bool:
     payload.origin_channel = payload.origin_channel or payload.channel
     payload.origin_chat_id = payload.origin_chat_id or payload.to
     if not payload.origin_metadata:
-        payload.origin_metadata = _persistable_origin_metadata(payload.channel_meta or {})
+        payload.origin_metadata = dict(payload.channel_meta or {})
 
     payload.deliver = False
     payload.channel = None

nanobot/providers/azure_openai_provider.py

@@ -34,7 +34,6 @@ from nanobot.providers.base import (
 )
 from nanobot.providers.openai_responses import (
     ResponsesStreamCapture,
-    build_responses_compaction_state,
     build_responses_state,
     consume_sdk_stream,
     convert_tools,
@@ -411,16 +410,6 @@ class AzureOpenAIProvider(LLMProvider):
                     output_items=capture.output_items,
                     usage=usage,
                 )
-                result.provider_compaction_state = build_responses_compaction_state(
-                    provider=self._responses_state_provider(),
-                    model=str(body["model"]),
-                    output_items=capture.output_items,
-                )
-                result.provider_compaction_applied = (
-                    result.provider_compaction_state is not None
-                )
-                if result.provider_compaction_applied:
-                    result.provider_compaction_scope = "current_request"
             return result
         except Exception as e:
             return self._handle_error(e)

nanobot/providers/base.py

@@ -31,7 +31,6 @@ RETRY_AFTER_BUFFER = 1
 
 RetryEventCallback = Callable[[str], Awaitable[None]]
 LLMCallObserver = Callable[["LLMCallRecord"], None]
-ProviderCompactionScope = Literal["prior_context", "current_request"]
 
 
 def resolve_stream_idle_timeout_s(
@@ -564,22 +563,6 @@ class LLMResponse:
     reasoning_content: str | None = None  # Kimi, DeepSeek-R1, MiMo etc.
     thinking_blocks: list[dict[str, Any]] | None = None  # Anthropic extended thinking
     provider_state: ProviderConversationState | None = field(default=None, repr=False)
-    # True only when this response installed a new provider-native compaction
-    # boundary. Replaying an older compaction item does not set this flag.
-    provider_compaction_applied: bool = field(default=False, repr=False)
-    # State immediately after native compaction, before the normal response
-    # continues. An archive prompt can resume this state without replaying H.
-    provider_compaction_state: ProviderConversationState | None = field(
-        default=None,
-        repr=False,
-    )
-    # Which model input the native compaction state replaces. Providers that
-    # compact before attaching the current request delta report
-    # ``prior_context``; in-request compaction reports ``current_request``.
-    provider_compaction_scope: ProviderCompactionScope | None = field(
-        default=None,
-        repr=False,
-    )
     # Routing wrappers may preserve or discard an incoming provider-owned
     # continuation independently of the final fallback error's retry policy.
     preserve_provider_state_on_error: bool | None = field(default=None, repr=False)
@@ -620,6 +603,8 @@ _SYNTHETIC_USER_CONTENT = "(conversation continued)"
 class LLMProvider(ABC):
     """Base class for LLM providers."""
 
+    supports_progress_deltas = False
+
     _CHAT_RETRY_DELAYS = (1, 2, 4)
     _PERSISTENT_MAX_DELAY = 60
     _PERSISTENT_IDENTICAL_ERROR_LIMIT = 10
@@ -1046,20 +1031,6 @@ class LLMProvider(ABC):
         # Unknown 429 defaults to WAIT+retry.
         return True
 
-    @staticmethod
-    def _content_as_blocks(content: Any) -> list[dict[str, Any]]:
-        """Convert message content to blocks so mixed user content can be merged."""
-        if isinstance(content, list):
-            return [
-                dict(cast(dict[str, Any], item))
-                if isinstance(item, dict)
-                else {"type": "text", "text": str(item)}
-                for item in cast(list[object], content)
-            ]
-        if content is None:
-            return []
-        return [{"type": "text", "text": str(content)}]
-
     @staticmethod
     def _enforce_role_alternation(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
         """Merge consecutive same-role messages and drop trailing assistant messages.
@@ -1094,13 +1065,6 @@ class LLMProvider(ABC):
                 curr_content = msg.get("content") or ""
                 if isinstance(prev_content, str) and isinstance(curr_content, str):
                     prev["content"] = (prev_content + "\n\n" + curr_content).strip()
-                elif role == "user":
-                    combined = dict(msg)
-                    combined["content"] = [
-                        *LLMProvider._content_as_blocks(prev_content),
-                        *LLMProvider._content_as_blocks(curr_content),
-                    ]
-                    merged[-1] = combined
                 else:
                     merged[-1] = dict(msg)
             else:

nanobot/providers/conversation_state.py

@@ -11,7 +11,6 @@ from nanobot.providers.base import (
     ProviderCallContext,
     ProviderConversationState,
 )
-from nanobot.utils.helpers import estimate_prompt_tokens_chain
 
 _PROVIDER_STATE_OUTPUT_META = "provider_state_output"
 _PROVIDER_STATE_BOUNDARY_META = "provider_state_boundary"
@@ -70,43 +69,6 @@ class ProviderConversationStateController:
             session_id=self._session_id,
         )
 
-    def estimate_request_context_tokens(
-        self,
-        messages: list[dict[str, Any]],
-        *,
-        model_messages: list[dict[str, Any]] | None = None,
-        supplemental_messages: list[dict[str, Any]] | None = None,
-        tool_definitions: list[dict[str, Any]] | None = None,
-    ) -> int | None:
-        """Estimate resumed state plus the pending delta for the next request."""
-        state = self.checkpoint(messages, model_messages=model_messages)
-        if state is None:
-            return None
-        context_tokens = state.payload.get("context_tokens")
-        if (
-            isinstance(context_tokens, bool)
-            or not isinstance(context_tokens, int)
-            or context_tokens < 0
-        ):
-            return None
-        pending_messages = [
-            *state.pending_messages,
-            *(supplemental_messages or []),
-        ]
-        delta_tokens, _ = estimate_prompt_tokens_chain(
-            self._provider,
-            self._model,
-            pending_messages,
-            tool_definitions,
-        )
-        return context_tokens + max(0, delta_tokens)
-
-    def replace_transcript(self, messages: list[dict[str, Any]]) -> None:
-        """Discard append-only provider state after a transcript rewrite."""
-        self._state = None
-        self._boundary = len(messages)
-        self._request_messages = []
-
     def prepare_request(
         self,
         messages: list[dict[str, Any]],
@@ -114,20 +76,11 @@ class ProviderConversationStateController:
         context_window_tokens: int | None,
         model_messages: list[dict[str, Any]] | None = None,
         supplemental_messages: list[dict[str, Any]] | None = None,
-        resume_state: bool = True,
     ) -> ProviderCallContext | None:
-        """Build context for the next request and remember its durable delta.
-
-        ``resume_state=False`` abandons opaque history when local request
-        fitting has produced a new independent model-facing context.
-        """
+        """Build typed context for the next request and remember its durable delta."""
         independent_context = self.independent_request_context(
             context_window_tokens=context_window_tokens,
         )
-        if not resume_state:
-            self._state = None
-            self._request_messages = []
-            return independent_context
         if self._state is None:
             self._request_messages = []
             return independent_context

nanobot/providers/fallback_provider.py

@@ -157,6 +157,10 @@ class FallbackProvider(LLMProvider):
         super().set_llm_call_observer(observer)
         self._primary.set_llm_call_observer(observer)
 
+    @property
+    def supports_progress_deltas(self) -> bool:
+        return bool(getattr(self._primary, "supports_progress_deltas", False))
+
     def can_resume_conversation_state(
         self,
         state: ProviderConversationState,

nanobot/providers/github_copilot_provider.py

@@ -5,7 +5,6 @@
 from __future__ import annotations
 
 import asyncio
-import hashlib
 import os
 import time
 import webbrowser
@@ -18,12 +17,7 @@ from oauth_cli_kit.models import OAuthToken
 from oauth_cli_kit.storage import FileTokenStorage
 
 from nanobot.providers.base import LLMResponse, ProviderCallContext
-from nanobot.providers.oauth_model_catalog import (
-    OAuthModelCatalog,
-    OAuthModelCatalogSnapshot,
-)
 from nanobot.providers.openai_compat_provider import OpenAICompatProvider
-from nanobot.providers.registry import ProviderModelSpec, find_by_name
 
 DEFAULT_GITHUB_DEVICE_CODE_URL = "https://github.com/login/device/code"
 DEFAULT_GITHUB_ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token"
@@ -102,9 +96,7 @@ def login_github_copilot(
 
         device_code = str(payload["device_code"])
         user_code = str(payload["user_code"])
-        verify_url = str(
-            payload.get("verification_uri") or payload.get("verification_uri_complete") or ""
-        )
+        verify_url = str(payload.get("verification_uri") or payload.get("verification_uri_complete") or "")
         verify_complete = str(payload.get("verification_uri_complete") or verify_url)
         interval = max(1, int(payload.get("interval") or 5))
         expires_in = int(payload.get("expires_in") or 900)
@@ -188,6 +180,8 @@ class GitHubCopilotProvider(OpenAICompatProvider):
         *,
         provider_name: str = "github_copilot",
     ):
+        from nanobot.providers.registry import find_by_name
+
         self._copilot_access_token: str | None = None
         self._copilot_expires_at: float = 0.0
         self._copilot_token_lock: asyncio.Lock = asyncio.Lock()
@@ -223,9 +217,7 @@ class GitHubCopilotProvider(OpenAICompatProvider):
                 )
 
             timeout = httpx.Timeout(20.0, connect=20.0)
-            async with httpx.AsyncClient(
-                timeout=timeout, follow_redirects=True, trust_env=True
-            ) as client:
+            async with httpx.AsyncClient(timeout=timeout, follow_redirects=True, trust_env=True) as client:
                 response = await client.get(
                     _resolve("NANOBOT_COPILOT_TOKEN_URL", DEFAULT_COPILOT_TOKEN_URL),
                     headers=_copilot_headers(github_token.access),
@@ -304,174 +296,3 @@ class GitHubCopilotProvider(OpenAICompatProvider):
             on_tool_call_delta=on_tool_call_delta,
             provider_context=provider_context,
         )
-
-
-def get_github_copilot_model_catalog(
-    proxy: str | None = None,
-) -> OAuthModelCatalogSnapshot:
-    storage = get_storage()
-    token = storage.load()
-    account_key = _catalog_account_key(getattr(token, "account_id", None))
-    cache_key = (
-        f"{storage.get_token_path()}\0{account_key}\0"
-        f"{_resolve('NANOBOT_COPILOT_BASE_URL', DEFAULT_COPILOT_BASE_URL)}\0{proxy or ''}"
-    )
-    return _GITHUB_COPILOT_MODEL_CATALOG.get(cache_key=cache_key, proxy=proxy)
-
-
-def invalidate_github_copilot_model_catalog() -> None:
-    _GITHUB_COPILOT_MODEL_CATALOG.invalidate()
-
-
-def _fetch_github_copilot_models(proxy: str | None) -> tuple[ProviderModelSpec, ...]:
-    github_token = get_storage().load()
-    if not github_token or not github_token.access:
-        raise RuntimeError("GitHub Copilot is not logged in")
-
-    common_headers = {
-        "Accept": "application/json",
-        "User-Agent": USER_AGENT,
-        "Editor-Version": EDITOR_VERSION,
-        "Editor-Plugin-Version": EDITOR_PLUGIN_VERSION,
-    }
-    client_kwargs: dict[str, Any] = {"timeout": 20.0, "follow_redirects": True}
-    if proxy:
-        client_kwargs.update(proxy=proxy, trust_env=False)
-    with httpx.Client(**client_kwargs) as client:
-        exchange = client.get(
-            _resolve("NANOBOT_COPILOT_TOKEN_URL", DEFAULT_COPILOT_TOKEN_URL),
-            headers={**common_headers, "Authorization": f"token {github_token.access}"},
-        )
-        exchange.raise_for_status()
-        exchange_mapping = _catalog_mapping(exchange.json())
-        copilot_token = exchange_mapping.get("token")
-        if not isinstance(copilot_token, str) or not copilot_token:
-            raise RuntimeError("GitHub Copilot token exchange returned no token")
-        endpoint_base = _catalog_first_text(
-            _catalog_mapping(exchange_mapping.get("endpoints")),
-            "api",
-        )
-        base_url = endpoint_base or _resolve(
-            "NANOBOT_COPILOT_BASE_URL",
-            DEFAULT_COPILOT_BASE_URL,
-        )
-        models_url = (
-            base_url
-            if base_url.rstrip("/").endswith("/models")
-            else f"{base_url.rstrip('/')}/models"
-        )
-        response = client.get(
-            models_url,
-            headers={**common_headers, "Authorization": f"Bearer {copilot_token}"},
-        )
-    response.raise_for_status()
-    return _parse_github_copilot_models(response.json())
-
-
-def _parse_github_copilot_models(payload: Any) -> tuple[ProviderModelSpec, ...]:
-    rows = cast(dict[str, Any], payload).get("data") if isinstance(payload, dict) else None
-    if not isinstance(rows, list):
-        return ()
-
-    fallback_models = _oauth_fallback_models("github_copilot")
-    fallback_by_id = {model.id.split("/", 1)[-1]: model for model in fallback_models}
-    models: list[ProviderModelSpec] = []
-    seen: set[str] = set()
-    for value in cast(list[object], rows):
-        if not isinstance(value, dict):
-            continue
-        row = cast(dict[str, Any], value)
-        wire_id = _catalog_first_text(row, "id")
-        policy = _catalog_mapping(row.get("policy"))
-        endpoints = row.get("supported_endpoints")
-        if (
-            not wire_id
-            or wire_id in seen
-            or row.get("model_picker_enabled") is not True
-            or policy.get("state") == "disabled"
-            or not _copilot_transport_supported(wire_id, endpoints)
-        ):
-            continue
-        seen.add(wire_id)
-        capabilities = _catalog_mapping(row.get("capabilities"))
-        supports = _catalog_mapping(capabilities.get("supports"))
-        limits = _catalog_mapping(capabilities.get("limits"))
-        fallback = fallback_by_id.get(wire_id)
-        models.append(
-            ProviderModelSpec(
-                id=f"github-copilot/{wire_id}",
-                label=(
-                    _catalog_first_text(row, "name")
-                    or (fallback.label if fallback is not None else wire_id)
-                ),
-                description=(fallback.description if fallback is not None else ""),
-                owned_by="GitHub Copilot",
-                context_window=(
-                    _catalog_positive_int(limits, "max_context_window_tokens")
-                    or (fallback.context_window if fallback is not None else None)
-                ),
-                reasoning_efforts=_catalog_reasoning_efforts(supports.get("reasoning_effort")),
-            )
-        )
-    return tuple(models)
-
-
-def _copilot_transport_supported(wire_id: str, endpoints: object) -> bool:
-    if not isinstance(endpoints, list):
-        return True
-    supported = cast(list[object], endpoints)
-    if "/chat/completions" in supported:
-        return True
-    model = wire_id.lower()
-    return "/responses" in supported and any(
-        token in model for token in ("gpt-5", "o1", "o3", "o4")
-    )
-
-
-def _oauth_fallback_models(provider_name: str) -> tuple[ProviderModelSpec, ...]:
-    spec = find_by_name(provider_name)
-    assert spec is not None
-    return spec.builtin_models
-
-
-def _catalog_account_key(account_id: object) -> str:
-    value = account_id if isinstance(account_id, str) else ""
-    return hashlib.sha256(value.encode()).hexdigest()[:16] if value else "anonymous"
-
-
-def _catalog_mapping(value: Any) -> dict[str, Any]:
-    return cast(dict[str, Any], value) if isinstance(value, dict) else {}
-
-
-def _catalog_first_text(row: dict[str, Any], *keys: str) -> str:
-    for key in keys:
-        value = row.get(key)
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-    return ""
-
-
-def _catalog_positive_int(row: dict[str, Any], *keys: str) -> int | None:
-    for key in keys:
-        value = row.get(key)
-        if isinstance(value, (int, float)) and not isinstance(value, bool) and value > 0:
-            return int(value)
-    return None
-
-
-def _catalog_reasoning_efforts(value: Any) -> tuple[str, ...]:
-    if not isinstance(value, list):
-        return ()
-    return tuple(
-        dict.fromkeys(
-            item.strip()
-            for item in cast(list[object], value)
-            if isinstance(item, str) and item.strip()
-        )
-    )
-
-
-_GITHUB_COPILOT_MODEL_CATALOG = OAuthModelCatalog(
-    fallback_models=_oauth_fallback_models("github_copilot"),
-    fetch=_fetch_github_copilot_models,
-)

nanobot/providers/oauth_model_catalog.py

@@ -1,224 +0,0 @@
-"""Shared cache seam for OAuth provider model discovery."""
-
-from __future__ import annotations
-
-import threading
-import time
-from collections.abc import Callable, Sequence
-from dataclasses import dataclass, replace
-from typing import Literal
-
-from loguru import logger
-
-from nanobot.providers.registry import ProviderModelSpec
-
-CatalogSource = Literal["remote", "cache", "stale", "fallback"]
-
-
-@dataclass(frozen=True, slots=True)
-class OAuthModelCatalogSnapshot:
-    """One usable catalog view, including where it came from."""
-
-    models: tuple[ProviderModelSpec, ...]
-    source: CatalogSource
-    fetched_at: float
-    message: str | None = None
-
-    def find(self, model: str) -> ProviderModelSpec | None:
-        wire_id = model.split("/", 1)[-1]
-        return next(
-            (item for item in self.models if item.id.split("/", 1)[-1] == wire_id),
-            None,
-        )
-
-
-@dataclass(frozen=True, slots=True)
-class _CacheEntry:
-    snapshot: OAuthModelCatalogSnapshot
-    stored_at: float
-
-
-class OAuthModelCatalog:
-    """Cache one provider's discovery behind a small failure-tolerant interface."""
-
-    def __init__(
-        self,
-        *,
-        fallback_models: Sequence[ProviderModelSpec],
-        fetch: Callable[[str | None], Sequence[ProviderModelSpec]],
-        fresh_ttl_s: float = 5 * 60,
-        stale_ttl_s: float = 24 * 60 * 60,
-        failure_ttl_s: float = 30,
-        max_entries: int = 8,
-        monotonic: Callable[[], float] = time.monotonic,
-        wall_clock: Callable[[], float] = time.time,
-    ) -> None:
-        if fresh_ttl_s < 0 or stale_ttl_s < fresh_ttl_s or failure_ttl_s < 0:
-            raise ValueError("catalog cache TTLs are invalid")
-        if max_entries < 1:
-            raise ValueError("catalog cache must allow at least one entry")
-        self._fallback_models = tuple(fallback_models)
-        self._fetch = fetch
-        self._fresh_ttl_s = fresh_ttl_s
-        self._stale_ttl_s = stale_ttl_s
-        self._failure_ttl_s = failure_ttl_s
-        self._max_entries = max_entries
-        self._monotonic = monotonic
-        self._wall_clock = wall_clock
-        self._condition = threading.Condition()
-        self._entries: dict[str, _CacheEntry] = {}
-        self._failures: dict[str, float] = {}
-        self._inflight: set[str] = set()
-        self._generation = 0
-
-    def get(self, *, cache_key: str, proxy: str | None = None) -> OAuthModelCatalogSnapshot:
-        """Return a fresh catalog, sharing concurrent work and retaining a fallback."""
-        with self._condition:
-            generation = self._generation
-            cached = self._cached_result(cache_key)
-            if cached is not None:
-                return cached
-            while cache_key in self._inflight:
-                self._condition.wait()
-                if generation != self._generation:
-                    return self._stale_or_fallback(None, self._monotonic())
-                cached = self._cached_result(cache_key)
-                if cached is not None:
-                    return cached
-            self._inflight.add(cache_key)
-
-        try:
-            models = tuple(self._fetch(proxy))
-            if not models:
-                raise ValueError("provider returned an empty model catalog")
-        except Exception as exc:
-            logger.warning("OAuth model catalog refresh failed: type={}", type(exc).__name__)
-            with self._condition:
-                result = (
-                    self._stale_or_fallback(None, self._monotonic())
-                    if generation != self._generation
-                    else self._failure_result(cache_key)
-                )
-        else:
-            now = self._monotonic()
-            result = OAuthModelCatalogSnapshot(
-                models=models,
-                source="remote",
-                fetched_at=self._wall_clock(),
-            )
-            with self._condition:
-                if generation != self._generation:
-                    result = self._stale_or_fallback(None, now)
-                else:
-                    self._store(cache_key, _CacheEntry(snapshot=result, stored_at=now))
-                    self._failures.pop(cache_key, None)
-        finally:
-            with self._condition:
-                self._inflight.discard(cache_key)
-                self._condition.notify_all()
-
-        return result
-
-    def invalidate(self) -> None:
-        """Drop cached work and prevent an older identity refresh from being stored."""
-        with self._condition:
-            self._generation += 1
-            self._entries.clear()
-            self._failures.clear()
-            self._condition.notify_all()
-
-    def _cached_result(self, cache_key: str) -> OAuthModelCatalogSnapshot | None:
-        now = self._monotonic()
-        entry = self._entries.get(cache_key)
-        if entry is not None and now - entry.stored_at < self._fresh_ttl_s:
-            return replace(entry.snapshot, source="cache")
-        failure_until = self._failures.get(cache_key)
-        if failure_until is not None and failure_until <= now:
-            self._failures.pop(cache_key, None)
-        elif failure_until is not None:
-            return self._stale_or_fallback(entry, now)
-        return None
-
-    def _failure_result(self, cache_key: str) -> OAuthModelCatalogSnapshot:
-        now = self._monotonic()
-        self._reserve(cache_key)
-        self._failures[cache_key] = now + self._failure_ttl_s
-        return self._stale_or_fallback(self._entries.get(cache_key), now)
-
-    def _stale_or_fallback(
-        self,
-        entry: _CacheEntry | None,
-        now: float,
-    ) -> OAuthModelCatalogSnapshot:
-        if entry is not None and now - entry.stored_at < self._stale_ttl_s:
-            return replace(
-                entry.snapshot,
-                source="stale",
-                message="Could not refresh the online model list; showing cached models.",
-            )
-        return OAuthModelCatalogSnapshot(
-            models=self._fallback_models,
-            source="fallback",
-            fetched_at=self._wall_clock(),
-            message="Could not load the online model list; showing built-in fallback models.",
-        )
-
-    def _store(self, cache_key: str, entry: _CacheEntry) -> None:
-        self._reserve(cache_key)
-        self._entries[cache_key] = entry
-
-    def _reserve(self, cache_key: str) -> None:
-        known = set(self._entries) | set(self._failures)
-        if cache_key in known or len(known) < self._max_entries:
-            return
-        oldest = min(
-            known,
-            key=lambda key: (
-                self._entries[key].stored_at
-                if key in self._entries
-                else self._failures[key] - self._failure_ttl_s
-            ),
-        )
-        self._entries.pop(oldest, None)
-        self._failures.pop(oldest, None)
-
-
-def get_oauth_model_catalog(
-    provider_name: str,
-    *,
-    proxy: str | None = None,
-) -> OAuthModelCatalogSnapshot:
-    """Discover models through the owning provider module."""
-    if provider_name == "openai_codex":
-        from nanobot.providers.openai_codex_provider import get_openai_codex_model_catalog
-
-        return get_openai_codex_model_catalog(proxy)
-    if provider_name == "xai_grok":
-        from nanobot.providers.xai_grok_provider import get_xai_grok_model_catalog
-
-        return get_xai_grok_model_catalog(proxy)
-    if provider_name == "github_copilot":
-        from nanobot.providers.github_copilot_provider import get_github_copilot_model_catalog
-
-        return get_github_copilot_model_catalog(proxy)
-    raise ValueError(f"OAuth model discovery is not available for {provider_name}")
-
-
-def invalidate_oauth_model_catalog(provider_name: str) -> None:
-    """Invalidate provider discovery after its OAuth identity changes."""
-    if provider_name == "openai_codex":
-        from nanobot.providers.openai_codex_provider import (
-            invalidate_openai_codex_model_catalog,
-        )
-
-        invalidate_openai_codex_model_catalog()
-    elif provider_name == "xai_grok":
-        from nanobot.providers.xai_grok_provider import invalidate_xai_grok_model_catalog
-
-        invalidate_xai_grok_model_catalog()
-    elif provider_name == "github_copilot":
-        from nanobot.providers.github_copilot_provider import (
-            invalidate_github_copilot_model_catalog,
-        )
-
-        invalidate_github_copilot_model_catalog()

nanobot/providers/openai_codex_provider.py

@@ -14,10 +14,7 @@ from typing import Any, cast
 import httpx
 from loguru import logger
 from oauth_cli_kit import get_token as get_codex_token
-from oauth_cli_kit.providers import OPENAI_CODEX_PROVIDER
-from oauth_cli_kit.storage import FileTokenStorage
 
-from nanobot import __version__
 from nanobot.providers.base import (
     LLMProvider,
     LLMResponse,
@@ -25,13 +22,8 @@ from nanobot.providers.base import (
     ProviderConversationState,
     resolve_stream_idle_timeout_s,
 )
-from nanobot.providers.oauth_model_catalog import (
-    OAuthModelCatalog,
-    OAuthModelCatalogSnapshot,
-)
 from nanobot.providers.openai_responses import (
     ResponsesStreamCapture,
-    build_responses_compaction_state,
     build_responses_state,
     consume_sse_with_reasoning,
     convert_tools,
@@ -43,11 +35,8 @@ from nanobot.providers.openai_responses import (
     responses_state_items,
     responses_state_matches,
 )
-from nanobot.providers.registry import ProviderModelSpec, find_by_name
 
 DEFAULT_CODEX_URL = "https://chatgpt.com/backend-api/codex/responses"
-DEFAULT_OPENAI_CODEX_MODELS_URL = "https://chatgpt.com/backend-api/codex/models"
-OPENAI_CODEX_CATALOG_CLIENT_VERSION = "0.144.0"
 DEFAULT_ORIGINATOR = "nanobot"
 _COMPACTION_RETAINED_CHAR_BUDGET = 256_000
 
@@ -55,6 +44,8 @@ _COMPACTION_RETAINED_CHAR_BUDGET = 256_000
 class OpenAICodexProvider(LLMProvider):
     """Use Codex OAuth to call the Responses API."""
 
+    supports_progress_deltas = True
+
     def __init__(
         self,
         default_model: str = "openai-codex/gpt-5.6-sol",
@@ -98,7 +89,9 @@ class OpenAICodexProvider(LLMProvider):
         model = model or self.default_model
         sanitized_messages = self._sanitize_empty_content(messages)
         sanitized_state = (
-            provider_context.conversation_state if provider_context is not None else None
+            provider_context.conversation_state
+            if provider_context is not None
+            else None
         )
         if sanitized_state is not None:
             sanitized_state = sanitized_state.with_pending_messages(
@@ -138,8 +131,6 @@ class OpenAICodexProvider(LLMProvider):
             body.update(self._extra_body)
 
         stage = "oauth_token"
-        native_compaction_applied = False
-        native_compaction_state: ProviderConversationState | None = None
         try:
             token = await asyncio.to_thread(get_codex_token, proxy=self.proxy)
             headers = _build_headers(cast(str, token.account_id), token.access)
@@ -179,7 +170,11 @@ class OpenAICodexProvider(LLMProvider):
                     )
 
             compact_threshold = resolve_compact_threshold(
-                (provider_context.context_window_tokens if provider_context is not None else None),
+                (
+                    provider_context.context_window_tokens
+                    if provider_context is not None
+                    else None
+                ),
                 max_tokens,
             )
             if (
@@ -190,11 +185,9 @@ class OpenAICodexProvider(LLMProvider):
                 and responses_state_context_tokens(sanitized_state) >= compact_threshold
             ):
                 stage = "codex_compaction"
-                history_items = responses_state_items(sanitized_state) or []
-                delta_items = input_items[len(history_items):]
                 compact_body = {
                     **body,
-                    "input": [*history_items, {"type": "compaction_trigger"}],
+                    "input": [*input_items, {"type": "compaction_trigger"}],
                 }
                 try:
                     compact_result = await _send(compact_body, emit_deltas=False)
@@ -210,16 +203,9 @@ class OpenAICodexProvider(LLMProvider):
                     }:
                         raise RuntimeError("Codex compaction returned no compaction item")
                     body["input"] = [
-                        *_retained_compaction_messages(history_items),
+                        *_retained_compaction_messages(input_items),
                         *compact_items,
-                        *delta_items,
                     ]
-                    native_compaction_state = build_responses_compaction_state(
-                        provider=self._responses_state_provider(),
-                        model=_strip_model_prefix(model),
-                        output_items=compact_items,
-                    )
-                    native_compaction_applied = True
                 except Exception as compact_error:
                     if is_compaction_compatibility_error(compact_error):
                         self._native_compaction_available = False
@@ -232,14 +218,7 @@ class OpenAICodexProvider(LLMProvider):
                     )
 
             stage = "codex_request"
-            result = await _send(body, emit_deltas=True)
-            result.provider_compaction_applied = (
-                result.provider_compaction_applied or native_compaction_applied
-            )
-            if native_compaction_state is not None:
-                result.provider_compaction_state = native_compaction_state
-                result.provider_compaction_scope = "prior_context"
-            return result
+            return await _send(body, emit_deltas=True)
         except Exception as e:
             response = _codex_error_response(e)
             exc_type = "CodexHTTPError" if isinstance(e, _CodexHTTPError) else type(e).__name__
@@ -259,12 +238,8 @@ class OpenAICodexProvider(LLMProvider):
             return response
 
     async def chat(
-        self,
-        messages: list[dict[str, Any]],
-        tools: list[dict[str, Any]] | None = None,
-        model: str | None = None,
-        max_tokens: int = 4096,
-        temperature: float = 0.7,
+        self, messages: list[dict[str, Any]], tools: list[dict[str, Any]] | None = None,
+        model: str | None = None, max_tokens: int = 4096, temperature: float = 0.7,
         reasoning_effort: str | None = None,
         tool_choice: str | dict[str, Any] | None = None,
         provider_context: ProviderCallContext | None = None,
@@ -291,12 +266,8 @@ class OpenAICodexProvider(LLMProvider):
         )
 
     async def chat_stream(
-        self,
-        messages: list[dict[str, Any]],
-        tools: list[dict[str, Any]] | None = None,
-        model: str | None = None,
-        max_tokens: int = 4096,
-        temperature: float = 0.7,
+        self, messages: list[dict[str, Any]], tools: list[dict[str, Any]] | None = None,
+        model: str | None = None, max_tokens: int = 4096, temperature: float = 0.7,
         reasoning_effort: str | None = None,
         tool_choice: str | dict[str, Any] | None = None,
         on_content_delta: Callable[[str], Awaitable[None]] | None = None,
@@ -375,7 +346,11 @@ def _without_response_item_ids(
             sanitized_input.append(raw_item)
             continue
         item = cast(dict[str, Any], raw_item)
-        sanitized_input.append({key: value for key, value in item.items() if key != "id"})
+        sanitized_input.append({
+            key: value
+            for key, value in item.items()
+            if key != "id"
+        })
 
     body = dict(request_body)
     body["input"] = sanitized_input
@@ -471,12 +446,15 @@ async def _request_codex(
                 raw = text.decode("utf-8", "ignore")
                 retry_after = LLMProvider._extract_retry_after_from_headers(response.headers)
                 error_type, error_code = LLMProvider._extract_error_type_code(raw)
-                compaction_unsupported = response.status_code in {400, 404, 422} and any(
-                    marker in raw.lower()
-                    for marker in (
-                        "context_management",
-                        "compact_threshold",
-                        "compaction_trigger",
+                compaction_unsupported = (
+                    response.status_code in {400, 404, 422}
+                    and any(
+                        marker in raw.lower()
+                        for marker in (
+                            "context_management",
+                            "compact_threshold",
+                            "compaction_trigger",
+                        )
                     )
                 )
                 raise _CodexHTTPError(
@@ -485,9 +463,7 @@ async def _request_codex(
                     retry_after=retry_after,
                     error_type=error_type,
                     error_code=error_code,
-                    should_retry=_should_retry_status(
-                        response.status_code, error_type, error_code, raw
-                    ),
+                    should_retry=_should_retry_status(response.status_code, error_type, error_code, raw),
                     compaction_unsupported=compaction_unsupported,
                 )
             capture = ResponsesStreamCapture()
@@ -560,9 +536,7 @@ def _codex_error_response(exc: Exception) -> LLMResponse:
         default_detail = "HTTP request failed"
 
     if status_code is not None and should_retry is None:
-        retry_content = (
-            None if int(status_code) == 429 and isinstance(exc, _CodexHTTPError) else detail
-        )
+        retry_content = None if int(status_code) == 429 and isinstance(exc, _CodexHTTPError) else detail
         should_retry = _should_retry_status(
             int(status_code),
             getattr(exc, "error_type", None),
@@ -620,139 +594,3 @@ def _should_retry_status(
             )
         )
     return status_code in LLMProvider._RETRYABLE_STATUS_CODES or status_code >= 500
-
-
-def get_openai_codex_model_catalog(
-    proxy: str | None = None,
-) -> OAuthModelCatalogSnapshot:
-    storage = FileTokenStorage(token_filename=OPENAI_CODEX_PROVIDER.token_filename)
-    token = storage.load()
-    account_id = getattr(token, "account_id", None)
-    account_key = _catalog_account_key(account_id)
-    cache_key = f"{storage.get_token_path()}\0{account_key}\0{proxy or ''}"
-    return _OPENAI_CODEX_MODEL_CATALOG.get(cache_key=cache_key, proxy=proxy)
-
-
-def invalidate_openai_codex_model_catalog() -> None:
-    _OPENAI_CODEX_MODEL_CATALOG.invalidate()
-
-
-def _fetch_openai_codex_models(proxy: str | None) -> tuple[ProviderModelSpec, ...]:
-    token = get_codex_token(proxy=proxy)
-    account_id = getattr(token, "account_id", None)
-    if not isinstance(account_id, str) or not account_id:
-        raise RuntimeError("OpenAI Codex OAuth token has no account ID")
-    client_kwargs: dict[str, Any] = {"timeout": 10.0, "follow_redirects": False}
-    if proxy:
-        client_kwargs.update(proxy=proxy, trust_env=False)
-    with httpx.Client(**client_kwargs) as client:
-        response = client.get(
-            DEFAULT_OPENAI_CODEX_MODELS_URL,
-            params={"client_version": OPENAI_CODEX_CATALOG_CLIENT_VERSION},
-            headers={
-                "Authorization": f"Bearer {token.access}",
-                "chatgpt-account-id": account_id,
-                "originator": DEFAULT_ORIGINATOR,
-                "User-Agent": f"nanobot/{__version__} (python)",
-                "accept": "application/json",
-            },
-        )
-    response.raise_for_status()
-    return _parse_openai_codex_models(response.json())
-
-
-def _parse_openai_codex_models(payload: Any) -> tuple[ProviderModelSpec, ...]:
-    rows = cast(dict[str, Any], payload).get("models") if isinstance(payload, dict) else None
-    if not isinstance(rows, list):
-        return ()
-
-    fallback_models = _oauth_fallback_models("openai_codex")
-    fallback_by_id = {model.id.split("/", 1)[-1]: model for model in fallback_models}
-    parsed: list[tuple[int, ProviderModelSpec]] = []
-    seen: set[str] = set()
-    for value in cast(list[object], rows):
-        if not isinstance(value, dict):
-            continue
-        row = cast(dict[str, Any], value)
-        wire_id = _catalog_first_text(row, "slug", "id")
-        if not wire_id or wire_id in seen or row.get("visibility") in {"hide", "none"}:
-            continue
-        seen.add(wire_id)
-        fallback = fallback_by_id.get(wire_id)
-        priority = row.get("priority")
-        parsed.append(
-            (
-                priority if isinstance(priority, int) and not isinstance(priority, bool) else 2**31,
-                ProviderModelSpec(
-                    id=f"openai-codex/{wire_id}",
-                    label=(
-                        _catalog_first_text(row, "display_name", "name")
-                        or (fallback.label if fallback is not None else wire_id)
-                    ),
-                    description=(
-                        _catalog_first_text(row, "description")
-                        or (fallback.description if fallback is not None else "")
-                    ),
-                    owned_by="OpenAI Codex",
-                    context_window=(
-                        _catalog_positive_int(row, "context_window")
-                        or (fallback.context_window if fallback is not None else None)
-                    ),
-                    reasoning_efforts=(
-                        _catalog_reasoning_efforts(row.get("supported_reasoning_levels"))
-                        or (fallback.reasoning_efforts if fallback is not None else ())
-                    ),
-                ),
-            )
-        )
-    parsed.sort(key=lambda item: item[0])
-    return tuple(model for _, model in parsed)
-
-
-def _oauth_fallback_models(provider_name: str) -> tuple[ProviderModelSpec, ...]:
-    spec = find_by_name(provider_name)
-    assert spec is not None
-    return spec.builtin_models
-
-
-def _catalog_account_key(account_id: object) -> str:
-    value = account_id if isinstance(account_id, str) else ""
-    return hashlib.sha256(value.encode()).hexdigest()[:16] if value else "anonymous"
-
-
-def _catalog_first_text(row: dict[str, Any], *keys: str) -> str:
-    for key in keys:
-        value = row.get(key)
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-    return ""
-
-
-def _catalog_positive_int(row: dict[str, Any], *keys: str) -> int | None:
-    for key in keys:
-        value = row.get(key)
-        if isinstance(value, (int, float)) and not isinstance(value, bool) and value > 0:
-            return int(value)
-    return None
-
-
-def _catalog_reasoning_efforts(value: Any) -> tuple[str, ...]:
-    if not isinstance(value, list):
-        return ()
-    efforts: list[str] = []
-    for item in cast(list[object], value):
-        if isinstance(item, str):
-            effort = item.strip()
-        elif isinstance(item, dict):
-            effort = _catalog_first_text(cast(dict[str, Any], item), "effort", "value", "id")
-        else:
-            effort = ""
-        if effort and effort not in efforts:
-            efforts.append(effort)
-    return tuple(efforts)
-
-
-_OPENAI_CODEX_MODEL_CATALOG = OAuthModelCatalog(
-    fallback_models=_oauth_fallback_models("openai_codex"),
-    fetch=_fetch_openai_codex_models,
-)

nanobot/providers/openai_compat_provider.py

@@ -36,7 +36,6 @@ from nanobot.providers.base import (
 )
 from nanobot.providers.openai_responses import (
     ResponsesStreamCapture,
-    build_responses_compaction_state,
     build_responses_state,
     consume_sdk_stream,
     convert_tools,
@@ -2050,18 +2049,6 @@ class OpenAICompatProvider(LLMProvider):
                             output_items=capture.output_items,
                             usage=usage,
                         )
-                        result.provider_compaction_state = (
-                            build_responses_compaction_state(
-                                provider=self._responses_state_provider(),
-                                model=str(body["model"]),
-                                output_items=capture.output_items,
-                            )
-                        )
-                        result.provider_compaction_applied = (
-                            result.provider_compaction_state is not None
-                        )
-                        if result.provider_compaction_applied:
-                            result.provider_compaction_scope = "current_request"
                     return result
                 except Exception as responses_error:
                     if self._spec and self._spec.name == "github_copilot":

nanobot/providers/openai_responses/__init__.py

@@ -18,7 +18,6 @@ from nanobot.providers.openai_responses.parsing import (
     parse_response_output,
 )
 from nanobot.providers.openai_responses.state import (
-    build_responses_compaction_state,
     build_responses_state,
     is_compaction_compatibility_error,
     prepare_responses_input,
@@ -41,7 +40,6 @@ __all__ = [
     "is_replayable_finish_reason",
     "map_finish_reason",
     "parse_response_output",
-    "build_responses_compaction_state",
     "build_responses_state",
     "is_compaction_compatibility_error",
     "prepare_responses_input",

nanobot/providers/openai_responses/parsing.py

@@ -11,10 +11,7 @@ import httpx
 from loguru import logger
 
 from nanobot.providers.base import LLMResponse, LLMUsage, ToolCallRequest, parse_tool_arguments
-from nanobot.providers.openai_responses.state import (
-    build_responses_compaction_state,
-    build_responses_state,
-)
+from nanobot.providers.openai_responses.state import build_responses_state
 
 FINISH_REASON_MAP = {
     "completed": "stop",
@@ -658,14 +655,6 @@ def parse_response_output(
             output_items=output,
             usage=usage,
         )
-        result.provider_compaction_state = build_responses_compaction_state(
-            provider=state_provider,
-            model=state_model,
-            output_items=output,
-        )
-        result.provider_compaction_applied = result.provider_compaction_state is not None
-        if result.provider_compaction_applied:
-            result.provider_compaction_scope = "current_request"
     return result
 
 

nanobot/providers/openai_responses/state.py

@@ -108,28 +108,6 @@ def build_responses_state(
     )
 
 
-def build_responses_compaction_state(
-    *,
-    provider: str,
-    model: str,
-    output_items: list[dict[str, Any]],
-) -> ProviderConversationState | None:
-    """Return the state at the latest native compaction output boundary."""
-    latest = None
-    for index, item in enumerate(output_items):
-        if item.get("type") in _COMPACTION_ITEM_TYPES:
-            latest = index
-    if latest is None:
-        return None
-    return ProviderConversationState(
-        kind=RESPONSES_STATE_KIND,
-        provider=provider,
-        model=model,
-        version=RESPONSES_STATE_VERSION,
-        payload={_ITEMS_KEY: [deepcopy(output_items[latest])]},
-    )
-
-
 def responses_state_items(
     state: ProviderConversationState,
 ) -> list[dict[str, Any]] | None:

nanobot/providers/registry.py

@@ -20,15 +20,12 @@ from pydantic.alias_generators import to_snake
 
 @dataclass(frozen=True)
 class ProviderModelSpec:
-    """Curated model metadata used for fixed catalogs or online fallback."""
+    """A curated model exposed by providers without a model-list endpoint."""
 
     id: str
     label: str = ""
     description: str = ""
-    owned_by: str = ""
     context_window: int | None = None
-    reasoning_efforts: tuple[str, ...] = ()
-    supports_backend_search: bool = False
 
 
 @dataclass(frozen=True)
@@ -45,7 +42,7 @@ class ProviderSpec:
     keywords: tuple[str, ...]  # model-name keywords for matching (lowercase)
     env_key: str  # env var for API key, e.g. "DASHSCOPE_API_KEY"
     display_name: str = ""  # shown in `nanobot status`
-    model_catalog: str = "auto"  # WebUI model-list source, including builtin/hybrid
+    model_catalog: str = "auto"  # WebUI model-list source
     builtin_models: tuple[ProviderModelSpec, ...] = ()
     settings_alias_for: str = ""  # compatibility alias grouped under this provider in Settings
 
@@ -410,56 +407,45 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
         keywords=("openai-codex",),
         env_key="",
         display_name="OpenAI Codex",
-        model_catalog="hybrid",
+        model_catalog="builtin",
         builtin_models=(
             ProviderModelSpec(
                 id="openai-codex/gpt-5.6-sol",
                 label="GPT-5.6-Sol",
                 description="Latest frontier agentic coding model.",
-                context_window=272_000,
-                reasoning_efforts=("low", "medium", "high", "xhigh", "max", "ultra"),
+                context_window=372000,
             ),
             ProviderModelSpec(
                 id="openai-codex/gpt-5.6-terra",
                 label="GPT-5.6-Terra",
                 description="Balanced agentic coding model for everyday work.",
-                context_window=272_000,
-                reasoning_efforts=("low", "medium", "high", "xhigh", "max", "ultra"),
+                context_window=372000,
             ),
             ProviderModelSpec(
                 id="openai-codex/gpt-5.6-luna",
                 label="GPT-5.6-Luna",
                 description="Fast and affordable agentic coding model.",
-                context_window=272_000,
-                reasoning_efforts=("low", "medium", "high", "xhigh", "max"),
+                context_window=372000,
             ),
             ProviderModelSpec(
                 id="openai-codex/gpt-5.5",
                 label="GPT-5.5",
                 description="Frontier model for complex coding, research, and real-world work.",
-                context_window=272_000,
-                reasoning_efforts=("low", "medium", "high", "xhigh"),
             ),
             ProviderModelSpec(
                 id="openai-codex/gpt-5.4",
                 label="GPT-5.4",
                 description="Strong model for everyday coding.",
-                context_window=272_000,
-                reasoning_efforts=("low", "medium", "high", "xhigh"),
             ),
             ProviderModelSpec(
                 id="openai-codex/gpt-5.4-mini",
                 label="GPT-5.4-Mini",
                 description="Small, fast, and cost-efficient model for simpler coding tasks.",
-                context_window=272_000,
-                reasoning_efforts=("low", "medium", "high", "xhigh"),
             ),
             ProviderModelSpec(
                 id="openai-codex/gpt-5.3-codex-spark",
                 label="GPT-5.3-Codex-Spark",
                 description="Ultra-fast coding model.",
-                context_window=128_000,
-                reasoning_efforts=("low", "medium", "high", "xhigh"),
             ),
         ),
         backend="openai_codex",
@@ -473,19 +459,13 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
         keywords=("xai-grok", "xai_grok"),
         env_key="",
         display_name="xAI Grok",
-        model_catalog="hybrid",
+        model_catalog="builtin",
         builtin_models=(
-            ProviderModelSpec(
-                id="xai-grok/grok-4.6",
-                label="Grok 4.6",
-                description="Grok via xAI subscription; X Search is enabled when supported.",
-                context_window=500_000,
-            ),
             ProviderModelSpec(
                 id="xai-grok/grok-4.5",
                 label="Grok 4.5",
                 description="Grok via xAI subscription; X Search is enabled when supported.",
-                context_window=500_000,
+                context_window=500000,
             ),
         ),
         backend="xai_grok",
@@ -498,19 +478,6 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
         keywords=("github_copilot", "copilot"),
         env_key="",
         display_name="Github Copilot",
-        model_catalog="hybrid",
-        builtin_models=(
-            ProviderModelSpec(
-                id="github-copilot/gpt-5.4-mini",
-                label="GPT-5.4 Mini",
-                description="GitHub Copilot Responses model.",
-            ),
-            ProviderModelSpec(
-                id="github-copilot/gpt-4.1",
-                label="GPT-4.1",
-                description="GitHub Copilot chat model.",
-            ),
-        ),
         backend="github_copilot",
         default_api_base="https://api.githubcopilot.com",
         strip_model_prefix=True,

nanobot/providers/xai_grok_provider.py

@@ -4,9 +4,9 @@ from __future__ import annotations
 
 import asyncio
 import base64
-import hashlib
 import json
 import re
+import time
 import uuid
 from collections.abc import Awaitable, Callable
 from typing import Any, cast
@@ -22,24 +22,21 @@ from nanobot.providers.base import (
     ToolCallRequest,
     resolve_stream_idle_timeout_s,
 )
-from nanobot.providers.oauth_model_catalog import OAuthModelCatalog, OAuthModelCatalogSnapshot
 from nanobot.providers.openai_responses import (
     consume_sse_with_reasoning,
     convert_messages,
     convert_tools,
 )
-from nanobot.providers.registry import ProviderModelSpec, find_by_name
 from nanobot.providers.xai_oauth import (
     XAI_CLIENT_VERSION,
-    get_xai_oauth_login_status,
-    get_xai_oauth_storage_path,
+    XAIToken,
     get_xai_oauth_token,
 )
 
-DEFAULT_XAI_GROK_MODEL = "xai-grok/grok-4.6"
 DEFAULT_XAI_GROK_URL = "https://cli-chat-proxy.grok.com/v1/responses"
 DEFAULT_XAI_GROK_MODELS_URL = "https://cli-chat-proxy.grok.com/v1/models"
-_HOSTED_SEARCH_MAX_TURNS = 5
+DEFAULT_XAI_GROK_MODEL = "xai-grok/grok-4.5"
+_MODEL_CAPABILITIES_TTL_S = 5 * 60
 _MAX_ERROR_BODY_CHARS = 1000
 _SENSITIVE_ERROR_KEYS = {
     "accesstoken",
@@ -66,9 +63,7 @@ def _is_named_x_search_tool(value: object) -> bool:
 class XAIGrokProvider(LLMProvider):
     """Call xAI's subscription proxy and expose supported hosted tools."""
 
-    # An incomplete hosted-tool stream can already have emitted answer text. Let the
-    # provider close that stream segment before its one bounded recovery attempt.
-    supports_stream_recover_callback = True
+    supports_progress_deltas = True
 
     def __init__(
         self,
@@ -82,19 +77,37 @@ class XAIGrokProvider(LLMProvider):
         self.default_model = default_model
         self.proxy = proxy or None
         self._extra_body = dict(extra_body or {})
+        self._model_capabilities: dict[str, bool] | None = None
+        self._model_capabilities_fetched_at = 0.0
 
-    async def _supports_backend_search(self, model: str) -> bool:
-        catalog = await asyncio.to_thread(
-            get_xai_grok_model_catalog,
-            self.proxy,
-        )
-        if catalog.message:
-            logger.warning(
-                "xAI model catalog unavailable; hosted X Search disabled unless cached: {}",
-                catalog.message,
-            )
-        info = catalog.find(model)
-        return bool(info and info.supports_backend_search)
+    async def _supports_backend_search(self, token: XAIToken, model: str) -> bool:
+        now = time.monotonic()
+        capabilities = self._model_capabilities
+        if (
+            capabilities is None
+            or now - self._model_capabilities_fetched_at >= _MODEL_CAPABILITIES_TTL_S
+        ):
+            try:
+                capabilities = await _fetch_xai_model_capabilities(
+                    DEFAULT_XAI_GROK_MODELS_URL,
+                    _build_model_headers(token),
+                    proxy=self.proxy,
+                )
+            except Exception as exc:
+                logger.warning(
+                    "xAI model capability lookup failed; hosted X Search disabled for model {}: "
+                    "type={} error={}",
+                    model,
+                    type(exc).__name__,
+                    str(exc).strip() or "unexpected error",
+                )
+                capabilities = {}
+                self._model_capabilities = capabilities
+                self._model_capabilities_fetched_at = now
+            else:
+                self._model_capabilities = capabilities
+                self._model_capabilities_fetched_at = now
+        return capabilities.get(model, False)
 
     async def _call_xai(
         self,
@@ -108,7 +121,6 @@ class XAIGrokProvider(LLMProvider):
         on_content_delta: Callable[[str], Awaitable[None]] | None = None,
         on_thinking_delta: Callable[[str], Awaitable[None]] | None = None,
         on_tool_call_delta: Callable[[dict[str, Any]], Awaitable[None]] | None = None,
-        on_stream_recover: Callable[[], Awaitable[None]] | None = None,
     ) -> LLMResponse:
         wire_model = _strip_model_prefix(model or self.default_model)
         system_prompt, input_items = convert_messages(messages)
@@ -118,13 +130,17 @@ class XAIGrokProvider(LLMProvider):
             token = await asyncio.to_thread(get_xai_oauth_token, proxy=self.proxy)
             configured_tools = self._extra_body.get("tools")
             tools_are_explicit = "tools" in self._extra_body
-            configured_hosted_search = isinstance(configured_tools, list) and any(
-                _is_hosted_x_search_tool(tool) for tool in cast(list[object], configured_tools)
+            configured_hosted_search = (
+                isinstance(configured_tools, list)
+                and any(
+                    _is_hosted_x_search_tool(tool)
+                    for tool in cast(list[object], configured_tools)
+                )
             )
             supports_backend_search = False
             if not tools_are_explicit:
                 stage = "model_capabilities"
-                supports_backend_search = await self._supports_backend_search(wire_model)
+                supports_backend_search = await self._supports_backend_search(token, wire_model)
             converted_tools = convert_tools(tools or [])
             if isinstance(configured_tools, list):
                 converted_tools.extend(cast(list[dict[str, Any]], configured_tools))
@@ -135,8 +151,6 @@ class XAIGrokProvider(LLMProvider):
             if supports_backend_search:
                 converted_tools.append({"type": "x_search"})
 
-            hosted_search_enabled = supports_backend_search or configured_hosted_search
-
             body: dict[str, Any] = {
                 "model": wire_model,
                 "store": False,
@@ -152,65 +166,51 @@ class XAIGrokProvider(LLMProvider):
                 "temperature": temperature,
                 "reasoning": _build_reasoning_options(reasoning_effort),
             }
-            if hosted_search_enabled:
-                # xAI's global default is intentionally unspecified. Five turns is
-                # their documented balanced setting and prevents a search from
-                # stopping after a single unsuccessful lookup.
-                body["max_turns"] = _HOSTED_SEARCH_MAX_TURNS
             if self._extra_body:
-                body.update(
-                    {key: value for key, value in self._extra_body.items() if key != "tools"}
-                )
+                body.update({
+                    key: value
+                    for key, value in self._extra_body.items()
+                    if key != "tools"
+                })
                 if tools_are_explicit and not isinstance(configured_tools, list):
                     body["tools"] = configured_tools
 
             headers = _build_headers(token.access, wire_model)
             stage = "xai_request"
-            auth_retried = False
-            hosted_tool_retried = False
-            retry_usage: LLMUsage | None = None
-            while True:
-                try:
-                    result = await _request_xai(
-                        DEFAULT_XAI_GROK_URL,
-                        headers,
-                        body,
-                        proxy=self.proxy,
-                        on_content_delta=on_content_delta,
-                        on_thinking_delta=on_thinking_delta,
-                        on_tool_call_delta=on_tool_call_delta,
-                    )
-                    break
-                except _XAIHTTPError as exc:
-                    if exc.status_code != 401 or auth_retried:
-                        raise
-                    auth_retried = True
-                    stage = "oauth_refresh"
-                    token = await asyncio.to_thread(
-                        get_xai_oauth_token,
-                        proxy=self.proxy,
-                        force_refresh=True,
-                    )
-                    headers = _build_headers(token.access, wire_model)
-                    stage = "xai_request_after_oauth_refresh"
-                except _XAIIncompleteHostedToolError as exc:
-                    retry_usage = _combine_usage(retry_usage, exc.usage)
-                    cannot_recover_stream = exc.stream_output_emitted and on_stream_recover is None
-                    if hosted_tool_retried or cannot_recover_stream:
-                        exc.usage = retry_usage
-                        raise
-                    hosted_tool_retried = True
-                    stage = "hosted_tool_recovery"
-                    logger.warning(
-                        "xAI response ended with unfinished hosted tool(s): {}; retrying once",
-                        ", ".join(exc.tool_names),
-                    )
-                    if on_stream_recover is not None:
-                        await on_stream_recover()
-                    headers = _build_headers(token.access, wire_model)
+            try:
+                result = await _request_xai(
+                    DEFAULT_XAI_GROK_URL,
+                    headers,
+                    body,
+                    proxy=self.proxy,
+                    on_content_delta=on_content_delta,
+                    on_thinking_delta=on_thinking_delta,
+                    on_tool_call_delta=on_tool_call_delta,
+                )
+            except _XAIHTTPError as exc:
+                if exc.status_code != 401:
+                    raise
+                stage = "oauth_refresh"
+                token = await asyncio.to_thread(
+                    get_xai_oauth_token,
+                    proxy=self.proxy,
+                    force_refresh=True,
+                )
+                self._model_capabilities = None
+                self._model_capabilities_fetched_at = 0.0
+                headers = _build_headers(token.access, wire_model)
+                stage = "xai_request_retry"
+                result = await _request_xai(
+                    DEFAULT_XAI_GROK_URL,
+                    headers,
+                    body,
+                    proxy=self.proxy,
+                    on_content_delta=on_content_delta,
+                    on_thinking_delta=on_thinking_delta,
+                    on_tool_call_delta=on_tool_call_delta,
+                )
 
             content, tool_calls, finish_reason, usage, reasoning_content = result
-            usage = _combine_usage(retry_usage, usage)
             return LLMResponse(
                 content=content,
                 tool_calls=tool_calls,
@@ -259,7 +259,6 @@ class XAIGrokProvider(LLMProvider):
         on_content_delta: Callable[[str], Awaitable[None]] | None = None,
         on_thinking_delta: Callable[[str], Awaitable[None]] | None = None,
         on_tool_call_delta: Callable[[dict[str, Any]], Awaitable[None]] | None = None,
-        on_stream_recover: Callable[[], Awaitable[None]] | None = None,
     ) -> LLMResponse:
         return await self._call_xai(
             messages,
@@ -272,7 +271,6 @@ class XAIGrokProvider(LLMProvider):
             on_content_delta,
             on_thinking_delta,
             on_tool_call_delta,
-            on_stream_recover,
         )
 
     def get_default_model(self) -> str:
@@ -292,14 +290,6 @@ def _build_reasoning_options(reasoning_effort: str | None) -> dict[str, str]:
     return options
 
 
-def _combine_usage(left: LLMUsage | None, right: LLMUsage | None) -> LLMUsage | None:
-    if left is None:
-        return right
-    if right is None:
-        return left
-    return left + right
-
-
 def _build_headers(token: str, model: str) -> dict[str, str]:
     conversation_id = str(uuid.uuid4())
     return {
@@ -320,6 +310,44 @@ def _build_headers(token: str, model: str) -> dict[str, str]:
     }
 
 
+def _build_model_headers(token: XAIToken) -> dict[str, str]:
+    headers = {
+        "Authorization": f"Bearer {token.access}",
+        "X-XAI-Token-Auth": "xai-grok-cli",
+        "x-grok-client-version": XAI_CLIENT_VERSION,
+        "x-grok-client-identifier": "nanobot",
+        "x-grok-client-mode": "headless",
+        "User-Agent": f"nanobot/{__version__} (python)",
+        "accept": "application/json",
+    }
+    claims = _decode_access_token_claims(token.access)
+    user_id = claims.get("sub")
+    if claims.get("principal_type") == "Team":
+        user_id = claims.get("principal_id") or user_id
+    if isinstance(user_id, str) and user_id:
+        headers["x-userid"] = user_id
+    email = claims.get("email")
+    if not isinstance(email, str) or "@" not in email:
+        email = token.account_id if token.account_id and "@" in token.account_id else None
+    if email:
+        headers["x-email"] = email
+    return headers
+
+
+def _decode_access_token_claims(token: str) -> dict[str, Any]:
+    """Read identity hints from the signed token; the server still authenticates it."""
+    parts = token.split(".")
+    if len(parts) < 2 or not parts[1]:
+        return {}
+    payload = parts[1]
+    try:
+        decoded = base64.urlsafe_b64decode(payload + "=" * (-len(payload) % 4))
+        claims = json.loads(decoded)
+    except (ValueError, TypeError):
+        return {}
+    return cast(dict[str, Any], claims) if isinstance(claims, dict) else {}
+
+
 class _XAIHTTPError(RuntimeError):
     def __init__(
         self,
@@ -341,25 +369,65 @@ class _XAIHTTPError(RuntimeError):
         self.response_body = response_body
 
 
-class _XAIIncompleteHostedToolError(RuntimeError):
-    """A nominally successful xAI stream ended before a hosted tool did."""
+async def _fetch_xai_model_capabilities(
+    url: str,
+    headers: dict[str, str],
+    *,
+    proxy: str | None = None,
+) -> dict[str, bool]:
+    client_kwargs: dict[str, Any] = {"timeout": 10.0, "follow_redirects": False}
+    if proxy:
+        client_kwargs.update(proxy=proxy, trust_env=False)
+    async with httpx.AsyncClient(**client_kwargs) as client:
+        response = await client.get(url, headers=headers)
+    if response.status_code != 200:
+        raw = response.content.decode("utf-8", "ignore")
+        raise _build_xai_http_error(response.status_code, response.headers, raw)
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise RuntimeError("xAI model catalog returned invalid JSON.") from exc
+    return _parse_xai_model_capabilities(payload)
 
-    should_retry = False  # _call_xai already performs the one safe recovery attempt.
 
-    def __init__(
-        self,
-        active_tools: list[dict[str, Any]],
-        *,
-        usage: LLMUsage | None,
-        stream_output_emitted: bool = False,
-    ) -> None:
-        names = [str(event.get("name") or "hosted_tool") for event in active_tools]
-        super().__init__(
-            "xAI ended the response before its hosted tool completed: " + ", ".join(names)
+def _parse_xai_model_capabilities(payload: Any) -> dict[str, bool]:
+    if isinstance(payload, dict):
+        payload = cast(dict[str, Any], payload)
+        rows: object = payload.get("data")
+        if not isinstance(rows, list):
+            rows = payload.get("models")
+    else:
+        rows = payload
+    if not isinstance(rows, list):
+        return {}
+
+    capabilities: dict[str, bool] = {}
+    for row_value in cast(list[object], rows):
+        if not isinstance(row_value, dict):
+            continue
+        row = cast(dict[str, Any], row_value)
+        meta_value = row.get("_meta")
+        meta = cast(dict[str, Any], meta_value) if isinstance(meta_value, dict) else {}
+        support_value = row.get("supportsBackendSearch")
+        if not isinstance(support_value, bool):
+            support_value = row.get("supports_backend_search")
+        if not isinstance(support_value, bool):
+            support_value = meta.get("supportsBackendSearch")
+        if not isinstance(support_value, bool):
+            support_value = meta.get("supports_backend_search")
+        supports_backend_search = support_value if isinstance(support_value, bool) else False
+
+        identifiers = (
+            row.get("model"),
+            row.get("modelId"),
+            row.get("id"),
+            meta.get("model"),
+            meta.get("modelId"),
         )
-        self.tool_names = tuple(names)
-        self.usage = usage
-        self.stream_output_emitted = stream_output_emitted
+        for identifier in identifiers:
+            if isinstance(identifier, str) and identifier.strip():
+                capabilities[_strip_model_prefix(identifier.strip())] = supports_backend_search
+    return capabilities
 
 
 async def _request_xai(
@@ -372,39 +440,10 @@ async def _request_xai(
     on_thinking_delta: Callable[[str], Awaitable[None]] | None = None,
     on_tool_call_delta: Callable[[dict[str, Any]], Awaitable[None]] | None = None,
 ) -> tuple[str, list[ToolCallRequest], str, LLMUsage | None, str | None]:
-    active_hosted_tools: dict[str, dict[str, Any]] = {}
-    stream_output_emitted = False
-
-    async def _forward_content_delta(delta: str) -> None:
-        nonlocal stream_output_emitted
-        if delta:
-            stream_output_emitted = True
-        if on_content_delta is not None:
-            await on_content_delta(delta)
-
-    async def _forward_thinking_delta(delta: str) -> None:
-        nonlocal stream_output_emitted
-        if delta:
-            stream_output_emitted = True
-        if on_thinking_delta is not None:
-            await on_thinking_delta(delta)
-
-    async def _track_and_forward_tool_event(event: dict[str, Any]) -> None:
-        if event.get("kind") == "hosted_tool":
-            call_id = event.get("call_id")
-            if call_id:
-                call_id = str(call_id)
-                if event.get("phase") == "start":
-                    active_hosted_tools[call_id] = dict(event)
-                elif event.get("phase") in {"end", "error"}:
-                    active_hosted_tools.pop(call_id, None)
-        if on_tool_call_delta is not None:
-            await on_tool_call_delta(event)
-
     async def _on_response_event(event: dict[str, Any]) -> None:
         hosted_event = _xai_hosted_tool_event(event)
-        if hosted_event is not None:
-            await _track_and_forward_tool_event(hosted_event)
+        if hosted_event is not None and on_tool_call_delta is not None:
+            await on_tool_call_delta(hosted_event)
 
     client_kwargs: dict[str, Any] = {"timeout": resolve_stream_idle_timeout_s()}
     if proxy:
@@ -415,34 +454,13 @@ async def _request_xai(
                 content = await response.aread()
                 raw = content.decode("utf-8", "ignore")
                 raise _build_xai_http_error(response.status_code, response.headers, raw)
-            result = await consume_sse_with_reasoning(
+            return await consume_sse_with_reasoning(
                 response,
-                on_content_delta=(_forward_content_delta if on_content_delta is not None else None),
-                # Always observe tool events so protocol validation also works for
-                # non-streaming callers that did not request UI progress callbacks.
-                on_tool_call_delta=_track_and_forward_tool_event,
-                on_reasoning_delta=(
-                    _forward_thinking_delta if on_thinking_delta is not None else None
-                ),
-                on_response_event=_on_response_event,
+                on_content_delta=on_content_delta,
+                on_tool_call_delta=on_tool_call_delta,
+                on_reasoning_delta=on_thinking_delta,
+                on_response_event=_on_response_event if on_tool_call_delta else None,
             )
-            if result[2] != "error" and active_hosted_tools:
-                active = list(active_hosted_tools.values())
-                for event in active:
-                    await _track_and_forward_tool_event(
-                        {
-                            **event,
-                            "phase": "error",
-                            "result": None,
-                            "error": "xAI ended the response before this hosted tool completed.",
-                        }
-                    )
-                raise _XAIIncompleteHostedToolError(
-                    active,
-                    usage=result[3],
-                    stream_output_emitted=stream_output_emitted,
-                )
-            return result
 
 
 def _xai_hosted_tool_event(event: dict[str, Any]) -> dict[str, Any] | None:
@@ -456,33 +474,19 @@ def _xai_hosted_tool_event(event: dict[str, Any]) -> dict[str, Any] | None:
             "phase": "start",
             "call_id": str(call_id),
             "name": "x_search",
-            "arguments": _xai_hosted_tool_arguments(event.get("input", event.get("arguments"))),
+            "arguments": _xai_hosted_tool_arguments(
+                event.get("input", event.get("arguments"))
+            ),
             "result": None,
         }
 
-    if event_type not in {"response.output_item.added", "response.output_item.done"}:
+    if event_type != "response.output_item.done":
         return None
     item = event.get("item")
     if not isinstance(item, dict):
         return None
     item = cast(dict[str, Any], item)
-    item_type = item.get("type")
-    if item_type == "x_search_call":
-        call_id = item.get("id") or item.get("call_id") or event.get("item_id")
-        if not call_id:
-            return None
-        phase = "start" if event_type == "response.output_item.added" else "end"
-        return {
-            "kind": "hosted_tool",
-            "phase": phase,
-            "call_id": str(call_id),
-            "name": "x_search",
-            "arguments": _xai_hosted_tool_arguments(item.get("action")),
-            "result": (
-                {"status": str(item.get("status") or "completed")} if phase == "end" else None
-            ),
-        }
-    if event_type != "response.output_item.done" or item_type != "custom_tool_call":
+    if item.get("type") != "custom_tool_call":
         return None
     tool_name = item.get("name")
     if not isinstance(tool_name, str) or not tool_name.startswith("x_"):
@@ -495,7 +499,9 @@ def _xai_hosted_tool_event(event: dict[str, Any]) -> dict[str, Any] | None:
         "phase": "end",
         "call_id": str(call_id),
         "name": "x_search",
-        "arguments": _xai_hosted_tool_arguments(item.get("input", item.get("arguments"))),
+        "arguments": _xai_hosted_tool_arguments(
+            item.get("input", item.get("arguments"))
+        ),
         # Keep the useful search subtype, but do not persist large hosted results
         # in WebUI activity messages. The model answer already carries citations.
         "result": {"name": tool_name},
@@ -604,8 +610,6 @@ def _xai_error_response(exc: Exception) -> LLMResponse:
         should_retry = True if should_retry is None else should_retry
     elif isinstance(exc, _XAIHTTPError):
         error_kind = "http"
-    elif isinstance(exc, _XAIIncompleteHostedToolError):
-        error_kind = "provider"
     if status_code is not None and should_retry is None:
         should_retry = _should_retry_status(
             int(status_code),
@@ -615,11 +619,9 @@ def _xai_error_response(exc: Exception) -> LLMResponse:
         )
     message = str(exc).strip() or "unexpected error"
     retry_after = getattr(exc, "retry_after", None)
-    usage = getattr(exc, "usage", None)
     return LLMResponse(
         content=f"Error calling xAI ({type(exc).__name__}): {message}",
         finish_reason="error",
-        usage=usage if isinstance(usage, LLMUsage) else None,
         retry_after=retry_after,
         error_status_code=int(status_code) if status_code is not None else None,
         error_kind=error_kind,
@@ -647,209 +649,3 @@ def _should_retry_status(
             )
         )
     return status_code in LLMProvider._RETRYABLE_STATUS_CODES or status_code >= 500  # pyright: ignore[reportPrivateUsage]
-
-
-def get_xai_grok_model_catalog(proxy: str | None = None) -> OAuthModelCatalogSnapshot:
-    token = get_xai_oauth_login_status()
-    account_key = _catalog_account_key(getattr(token, "account_id", None))
-    cache_key = f"{get_xai_oauth_storage_path()}\0{account_key}\0{proxy or ''}"
-    return _XAI_GROK_MODEL_CATALOG.get(cache_key=cache_key, proxy=proxy)
-
-
-def invalidate_xai_grok_model_catalog() -> None:
-    _XAI_GROK_MODEL_CATALOG.invalidate()
-
-
-def _fetch_xai_grok_models(proxy: str | None) -> tuple[ProviderModelSpec, ...]:
-    token = get_xai_oauth_token(proxy=proxy)
-    client_kwargs: dict[str, Any] = {"timeout": 10.0, "follow_redirects": False}
-    if proxy:
-        client_kwargs.update(proxy=proxy, trust_env=False)
-    with httpx.Client(**client_kwargs) as client:
-        response = client.get(
-            DEFAULT_XAI_GROK_MODELS_URL,
-            headers=_build_xai_model_headers(token.access, token.account_id),
-        )
-    response.raise_for_status()
-    return _parse_xai_grok_models(response.json())
-
-
-def _parse_xai_grok_models(payload: Any) -> tuple[ProviderModelSpec, ...]:
-    if isinstance(payload, dict):
-        payload_mapping = cast(dict[str, Any], payload)
-        rows: object = payload_mapping.get("data")
-        if not isinstance(rows, list):
-            rows = payload_mapping.get("models")
-    else:
-        rows = payload
-    if not isinstance(rows, list):
-        return ()
-
-    fallback_models = _oauth_fallback_models("xai_grok")
-    fallback_by_id = {model.id.split("/", 1)[-1]: model for model in fallback_models}
-    models: list[ProviderModelSpec] = []
-    seen: set[str] = set()
-    for value in cast(list[object], rows):
-        if not isinstance(value, dict):
-            continue
-        row = cast(dict[str, Any], value)
-        meta = _catalog_mapping(row.get("_meta"))
-        raw_id = next(
-            (
-                candidate.strip()
-                for candidate in (
-                    row.get("id"),
-                    row.get("model"),
-                    row.get("modelId"),
-                    row.get("name"),
-                    meta.get("id"),
-                    meta.get("model"),
-                    meta.get("modelId"),
-                )
-                if isinstance(candidate, str) and candidate.strip()
-            ),
-            None,
-        )
-        if raw_id is None:
-            continue
-        wire_id = raw_id.split("/", 1)[-1]
-        if wire_id in seen:
-            continue
-        seen.add(wire_id)
-        fallback = fallback_by_id.get(wire_id)
-        label = _catalog_first_text(row, "display_name", "label", "name") or _catalog_first_text(
-            meta,
-            "display_name",
-            "label",
-            "name",
-        )
-        if not label or label == raw_id:
-            label = fallback.label if fallback is not None else wire_id
-        models.append(
-            ProviderModelSpec(
-                id=f"xai-grok/{wire_id}",
-                label=label,
-                description=(
-                    _catalog_first_text(row, "description")
-                    or _catalog_first_text(meta, "description")
-                    or (fallback.description if fallback is not None else "")
-                ),
-                owned_by=(
-                    _catalog_first_text(row, "owned_by", "owner", "organization")
-                    or _catalog_first_text(meta, "owned_by", "owner", "organization")
-                    or (fallback.owned_by if fallback is not None else "xAI")
-                ),
-                context_window=(
-                    _catalog_positive_int(row, "context_window", "context_length")
-                    or _catalog_positive_int(meta, "context_window", "context_length")
-                    or (fallback.context_window if fallback is not None else None)
-                ),
-                reasoning_efforts=_catalog_reasoning_efforts(
-                    row.get("reasoning_efforts", meta.get("reasoning_efforts"))
-                ),
-                supports_backend_search=_catalog_bool_field(
-                    row,
-                    "supports_backend_search",
-                    "supportsBackendSearch",
-                ),
-            )
-        )
-    return tuple(models)
-
-
-def _build_xai_model_headers(access_token: str, account_id: str | None) -> dict[str, str]:
-    headers = {
-        "Authorization": f"Bearer {access_token}",
-        "X-XAI-Token-Auth": "xai-grok-cli",
-        "x-grok-client-version": XAI_CLIENT_VERSION,
-        "x-grok-client-identifier": "nanobot",
-        "x-grok-client-mode": "headless",
-        "User-Agent": f"nanobot/{__version__} (python)",
-        "accept": "application/json",
-    }
-    claims = _decode_access_token_claims(access_token)
-    user_id = claims.get("sub")
-    if claims.get("principal_type") == "Team":
-        user_id = claims.get("principal_id") or user_id
-    if isinstance(user_id, str) and user_id:
-        headers["x-userid"] = user_id
-    email = claims.get("email")
-    if not isinstance(email, str) or "@" not in email:
-        email = account_id if account_id and "@" in account_id else None
-    if email:
-        headers["x-email"] = email
-    return headers
-
-
-def _decode_access_token_claims(token: str) -> dict[str, Any]:
-    parts = token.split(".")
-    if len(parts) < 2 or not parts[1]:
-        return {}
-    try:
-        decoded = base64.urlsafe_b64decode(parts[1] + "=" * (-len(parts[1]) % 4))
-        claims = json.loads(decoded)
-    except (ValueError, TypeError):
-        return {}
-    return cast(dict[str, Any], claims) if isinstance(claims, dict) else {}
-
-
-def _oauth_fallback_models(provider_name: str) -> tuple[ProviderModelSpec, ...]:
-    spec = find_by_name(provider_name)
-    assert spec is not None
-    return spec.builtin_models
-
-
-def _catalog_account_key(account_id: object) -> str:
-    value = account_id if isinstance(account_id, str) else ""
-    return hashlib.sha256(value.encode()).hexdigest()[:16] if value else "anonymous"
-
-
-def _catalog_mapping(value: Any) -> dict[str, Any]:
-    return cast(dict[str, Any], value) if isinstance(value, dict) else {}
-
-
-def _catalog_first_text(row: dict[str, Any], *keys: str) -> str:
-    for key in keys:
-        value = row.get(key)
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-    return ""
-
-
-def _catalog_positive_int(row: dict[str, Any], *keys: str) -> int | None:
-    for key in keys:
-        value = row.get(key)
-        if isinstance(value, (int, float)) and not isinstance(value, bool) and value > 0:
-            return int(value)
-    return None
-
-
-def _catalog_bool_field(row: dict[str, Any], *keys: str) -> bool:
-    for key in keys:
-        value = row.get(key)
-        if isinstance(value, bool):
-            return value
-    meta = row.get("_meta")
-    return _catalog_bool_field(_catalog_mapping(meta), *keys) if isinstance(meta, dict) else False
-
-
-def _catalog_reasoning_efforts(value: Any) -> tuple[str, ...]:
-    if not isinstance(value, list):
-        return ()
-    efforts: list[str] = []
-    for item in cast(list[object], value):
-        if isinstance(item, str):
-            effort = item.strip()
-        elif isinstance(item, dict):
-            effort = _catalog_first_text(cast(dict[str, Any], item), "effort", "value", "id")
-        else:
-            effort = ""
-        if effort and effort not in efforts:
-            efforts.append(effort)
-    return tuple(efforts)
-
-
-_XAI_GROK_MODEL_CATALOG = OAuthModelCatalog(
-    fallback_models=_oauth_fallback_models("xai_grok"),
-    fetch=_fetch_xai_grok_models,
-)

nanobot/sdk/clients.py

@@ -209,11 +209,11 @@ class RuntimeClient:
         return self._loop.runtime_events.subscribe(handler, SessionTurnPersisted)
 
     async def compact_session(self, session_key: str) -> SessionSnapshot:
-        """Archive one session through the shared idle-compaction path."""
+        """Run token consolidation for one session."""
         session = self._loop.sessions.get_or_create(session_key)
         runtime = self._loop.runtime_for_session(session)
-        await self._loop.consolidator.compact_idle_session(
-            session_key,
+        await self._loop.consolidator.maybe_consolidate_by_tokens(
+            session,
             runtime=runtime,
         )
         return snapshot_from_session(self._loop.sessions.get_or_create(session_key))

nanobot/session/manager.py

@@ -27,9 +27,7 @@ from nanobot.runtime_context import (
     RUNTIME_CONTEXT_HISTORY_META,
     public_history_message,
 )
-from nanobot.session.history_visibility import is_hidden_history_message
 from nanobot.session.model_selection import SESSION_MODEL_PRESET_METADATA_KEY
-from nanobot.session.summary import SUMMARY_CONTINUATION_TEXT
 from nanobot.utils.helpers import (
     content_with_media_breadcrumbs,
     ensure_dir,
@@ -84,15 +82,6 @@ def _json_object(value: object) -> dict[str, Any]:
     return cast(dict[str, Any], value)
 
 
-def _archive_offset(data: dict[str, Any]) -> int:
-    """Read the Memory archive watermark across the field-name migration."""
-    for key in ("last_archived", "last_consolidated"):
-        offset = cast(object, data.get(key))
-        if isinstance(offset, int) and not isinstance(offset, bool):
-            return offset
-    return 0
-
-
 # TODO(0.3.2): Remove the write_stdin replay migration after 0.3.1.
 def _migrate_legacy_exec_arguments(container: dict[str, Any]) -> bool:
     raw_arguments = cast(object, container.get("arguments"))
@@ -264,6 +253,12 @@ def _metadata_title(metadata: object) -> str:
     return strip_think(title)
 
 
+@dataclass
+class RetentionResult:
+    dropped: list[dict[str, Any]]
+    already_consolidated_count: int
+
+
 @dataclass(frozen=True)
 class SessionPolicy:
     """Runtime rules that do not belong in durable session data."""
@@ -282,8 +277,7 @@ class Session:
     created_at: datetime = field(default_factory=datetime.now)
     updated_at: datetime = field(default_factory=datetime.now)
     metadata: dict[str, Any] = field(default_factory=dict)
-    # Keep the legacy storage name while persisted sessions and SDK callers migrate.
-    last_consolidated: int = 0
+    last_consolidated: int = 0  # Number of messages already consolidated to files
     provider_state: ProviderConversationState | None = field(default=None, repr=False)
     policy: SessionPolicy = field(default_factory=SessionPolicy, repr=False, compare=False)
 
@@ -301,15 +295,6 @@ class Session:
         ):
             self.last_consolidated = 0
 
-    @property
-    def last_archived(self) -> int:
-        """End of the latest committed Memory checkpoint."""
-        return self.last_consolidated
-
-    @last_archived.setter
-    def last_archived(self, value: int) -> None:
-        self.last_consolidated = value
-
     def add_message(self, role: str, content: str, **kwargs: Any) -> None:
         """Add a message to the session."""
         msg = {
@@ -331,17 +316,14 @@ class Session:
     ) -> list[dict[str, Any]]:
         """Return recent replayable messages for LLM input.
 
-        A committed in-turn checkpoint replaces its old prefix with the stored
-        summary and resumes replay at a hidden continuation marker. A positive
-        ``max_messages`` applies an additional caller-owned count limit.
+        A positive ``max_messages`` applies an explicit caller-owned count
+        limit. The normal model path relies on ``max_tokens`` instead.
         """
-        replay_start = self.last_archived
-        resumes_from_checkpoint = (
-            replay_start < len(self.messages)
-            and is_hidden_history_message(self.messages[replay_start])
-            and self.messages[replay_start].get("content") == SUMMARY_CONTINUATION_TEXT
-        )
-        if replay_start and not resumes_from_checkpoint:
+        replay_start = self.last_consolidated
+        if replay_start:
+            # ``last_consolidated`` is archive progress, not a replay boundary.
+            # Keep a small raw suffix for continuity, extending back to the user
+            # that started an assistant/tool sequence when necessary.
             recent_start = recent_message_start_index(
                 self.messages,
                 MIN_COMPACTED_REPLAY_MESSAGES,
@@ -353,8 +335,8 @@ class Session:
         if max_messages <= 0:
             start_idx = 0
         else:
-            unarchived_count = len(self.messages) - self.last_archived
-            if replay_start < self.last_archived and unarchived_count < max_messages:
+            unarchived_count = len(self.messages) - self.last_consolidated
+            if replay_start < self.last_consolidated and unarchived_count < max_messages:
                 # The archived replay suffix can exceed the nominal count when one
                 # tool-heavy turn spans the boundary. Preserve that complete turn.
                 start_idx = 0
@@ -477,11 +459,115 @@ class Session:
     def clear(self) -> None:
         """Clear all messages and reset session to initial state."""
         self.messages = []
-        self.last_archived = 0
+        self.last_consolidated = 0
         self.provider_state = None
         self.updated_at = datetime.now()
         self.metadata.pop("_last_summary", None)
 
+    def retain_recent_legal_suffix(
+        self,
+        max_messages: int,
+        *,
+        extend_to_user: bool = False,
+    ) -> RetentionResult:
+        """Keep a legal recent suffix, optionally extending it back to a user turn.
+
+        Returns a RetentionResult with dropped messages and how many of those
+        were in the already-consolidated prefix. This method mutates
+        self.messages and self.last_consolidated in place.
+        """
+        if max_messages <= 0:
+            dropped = list(self.messages)
+            lc = self.last_consolidated
+            self.clear()
+            return RetentionResult(
+                dropped=dropped,
+                already_consolidated_count=min(lc, len(dropped)),
+            )
+        if len(self.messages) <= max_messages:
+            return RetentionResult(
+                dropped=[],
+                already_consolidated_count=0,
+            )
+
+        original = list(self.messages)
+        before_lc = self.last_consolidated
+
+        start_idx = max(0, len(self.messages) - max_messages)
+        if extend_to_user:
+            recovered_user = next(
+                (i for i in range(start_idx, -1, -1) if self.messages[i].get("role") == "user"),
+                None,
+            )
+            if recovered_user is not None:
+                start_idx = recovered_user
+                if start_idx > 0 and self.messages[start_idx - 1].get("_channel_delivery"):
+                    start_idx -= 1
+
+        retained = self.messages[start_idx:]
+
+        # Prefer starting at a user turn (or its preceding _channel_delivery) when one exists within the retained window.
+        first_user = next((i for i, m in enumerate(retained) if m.get("role") == "user"), None)
+        if first_user is not None:
+            if first_user > 0 and retained[first_user - 1].get("_channel_delivery"):
+                retained = retained[first_user - 1:]
+            else:
+                retained = retained[first_user:]
+        elif not extend_to_user:
+            # If the hard-capped tail is assistant/tool-only, anchor to the
+            # latest user in the full session and take a capped forward window.
+            latest_user = next(
+                (i for i in range(len(self.messages) - 1, -1, -1)
+                 if self.messages[i].get("role") == "user"),
+                None,
+            )
+            if latest_user is not None:
+                retained = self.messages[latest_user: latest_user + max_messages]
+
+        # Mirror get_history(): avoid persisting orphan tool results at the front.
+        start = find_legal_message_start(retained)
+        if start:
+            retained = retained[start:]
+
+        # Hard-cap guarantee unless the caller requested user-turn extension.
+        if not extend_to_user and len(retained) > max_messages:
+            retained = retained[-max_messages:]
+            start = find_legal_message_start(retained)
+            if start:
+                retained = retained[start:]
+
+        # Compute actually-dropped messages using identity comparison so that
+        # even when retained is a non-contiguous slice of original (the else
+        # branch above), we never duplicate or lose messages.
+        retained_ids = set(id(m) for m in retained)
+        dropped = [m for m in original if id(m) not in retained_ids]
+
+        # Count how many dropped messages were in the already-consolidated
+        # prefix of the original list.  This cannot be a simple min() because
+        # dropped may include messages from *after* the consolidated prefix
+        # (e.g. in the else branch).
+        already_consolidated = sum(
+            1 for i, m in enumerate(original)
+            if i < before_lc and id(m) not in retained_ids
+        )
+
+        # New last_consolidated = count of retained messages that were inside
+        # the old consolidated prefix.
+        new_lc = sum(
+            1 for i, m in enumerate(original)
+            if i < before_lc and id(m) in retained_ids
+        )
+
+        self.messages = retained
+        self.last_consolidated = new_lc
+        if dropped:
+            self.provider_state = None
+        self.updated_at = datetime.now()
+        return RetentionResult(
+            dropped=dropped,
+            already_consolidated_count=already_consolidated,
+        )
+
 class SessionPayload(TypedDict):
     key: str
     created_at: str | None
@@ -1081,7 +1167,12 @@ class JsonlSessionStore:
                             if isinstance(updated_at_value, str) and updated_at_value
                             else None
                         )
-                        last_consolidated = _archive_offset(data)
+                        offset = cast(object, data.get("last_consolidated", 0))
+                        last_consolidated = (
+                            offset
+                            if isinstance(offset, int) and not isinstance(offset, bool)
+                            else 0
+                        )
                     elif record_type == _PROVIDER_STATE_RECORD_TYPE:
                         provider_state = ProviderConversationState.from_private_record(
                             data.get("state")
@@ -1163,7 +1254,12 @@ class JsonlSessionStore:
                         if isinstance(updated_at_value, str) and updated_at_value:
                             with suppress(ValueError):
                                 updated_at = datetime.fromisoformat(updated_at_value)
-                        last_consolidated = _archive_offset(data)
+                        offset = cast(object, data.get("last_consolidated", 0))
+                        last_consolidated = (
+                            offset
+                            if isinstance(offset, int) and not isinstance(offset, bool)
+                            else 0
+                        )
                     elif record_type == _PROVIDER_STATE_RECORD_TYPE:
                         candidate = ProviderConversationState.from_private_record(
                             data.get("state")
@@ -1323,9 +1419,6 @@ class JsonlSessionStore:
                     "created_at": session.created_at.isoformat(),
                     "updated_at": session.updated_at.isoformat(),
                     "metadata": session.metadata,
-                    "last_archived": session.last_archived,
-                    # Keep old nanobot releases able to read sessions written
-                    # during the field-name migration.
                     "last_consolidated": session.last_consolidated,
                 }
                 f.write(json.dumps(metadata_line, ensure_ascii=False) + "\n")
@@ -1903,7 +1996,7 @@ class SessionManager:
         user_index = 0
         found_target = False
         for message in source.messages:
-            if message.get("role") == "user" and not is_hidden_history_message(message):
+            if message.get("role") == "user":
                 if user_index == before_user_index:
                     found_target = True
                     break
@@ -1918,8 +2011,8 @@ class SessionManager:
         for key in _FORK_VOLATILE_METADATA_KEYS:
             metadata.pop(key, None)
 
-        last_consolidated = min(source.last_archived, len(copied))
-        if source.last_archived > len(copied):
+        last_consolidated = min(source.last_consolidated, len(copied))
+        if source.last_consolidated > len(copied):
             metadata.pop("_last_summary", None)
             last_consolidated = 0
 

nanobot/session/summary.py

@@ -3,27 +3,15 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from dataclasses import dataclass
 from datetime import datetime
 from typing import TypedDict, cast
 
-SUMMARY_CONTINUATION_TEXT = (
-    "Continue the active task from the working-memory checkpoint above."
-)
 
 class SessionSummary(TypedDict):
     text: str
     last_active: str
 
 
-@dataclass(frozen=True, slots=True)
-class SessionSummaryCheckpoint:
-    """A replacement summary and the raw transcript boundary it covers."""
-
-    summary: str
-    transcript_boundary: int
-
-
 def session_summary_from_metadata(
     metadata: Mapping[str, object] | None,
     *,

nanobot/session/turn_continuation.py

@@ -147,10 +147,10 @@ def prepare_save_boundary(ctx: TurnContext) -> None:
     if ctx.session is not None:
         clear_internal_continuation_state(ctx.session.metadata)
 
-    assert ctx.transcript_input is not None
     ctx.save_skip = _save_skip_for_turn(
         message_metadata=ctx.msg.metadata,
-        initial_message_count=ctx.transcript_input.message_count,
+        initial_message_count=len(ctx.initial_messages),
+        history_count=len(ctx.history),
         input_persisted_early=ctx.input_persisted_early,
     )
 
@@ -185,6 +185,7 @@ def _save_skip_for_turn(
     *,
     message_metadata: Mapping[str, Any] | None,
     initial_message_count: int,
+    history_count: int,
     input_persisted_early: bool,
 ) -> int:
     """Return the persisted-message append boundary for this turn."""
@@ -192,7 +193,10 @@ def _save_skip_for_turn(
         return initial_message_count
     if internal_continuation_inbound(message_metadata):
         return initial_message_count
-    if not input_persisted_early:
+    # build_messages may merge the current message into a same-role history tail.
+    # Runner-appended messages start at initial_message_count in either shape.
+    has_standalone_current = initial_message_count > 1 + history_count
+    if has_standalone_current and not input_persisted_early:
         return initial_message_count - 1
     return initial_message_count
 

nanobot/templates/agent/consolidator_archive.md

@@ -1,42 +1,25 @@
-Create a compact replacement checkpoint for this session.
+Create a memory overview for only the final {{ archive_count }} conversation messages immediately before this instruction. Earlier messages are context for resolving references; do not summarize them again.
 
-When `[Archived Context Summary]` appears in the system prompt, update that previous checkpoint to reflect the current conversation state.
+Use [skip] unless a fact meets all SNIP criteria:
+- Signal: would the user need to repeat this if forgotten?
+- Novel: not just a restatement of another fact in this same conversation chunk
+- Important: prevents rework or captures preferences / rules
+- Persistent: still relevant after 2 weeks
 
-## Merge rules
+Format each fact as:
+- [mark] fact content
 
-- Use the latest correction or decision as the current version of a fact, and merge duplicates.
-- Preserve exact names, identifiers, paths, commands, decisions, results, and unresolved blockers when they are needed to continue the session.
-- Retain a fact already present in long-term memory when it is needed for session continuity.
+Marks (choose the best match):
+- [permanent] Core preferences, personal traits, habits — never becomes stale
+- [durable] Technical discoveries, project knowledge, config details — valid for months
+- [ephemeral] Active task state, temporary decisions — may change in weeks
+- [correction] Correction to a previous memory — state what changed
+- [skip] Conversational filler, code/source facts derivable from the repo, or audit-only breadcrumbs
 
-## What to retain
+Priority: user corrections and preferences > solutions > decisions > events > environment facts.
 
-Always retain a compact working-state handoff:
-- active objective
-- current status
-- completed results that constrain later work
-- unresolved blockers
-- next action
-- exact identifiers needed for that action
+Do not output facts already present in the system prompt's Recent History.
 
-Mark working-state facts `[ephemeral]`.
+Do not mark something [skip] merely because it might already exist in long-term memory.
 
-For other facts, retain a candidate only when it meets all four SNIP criteria:
-- Signal: remembering it saves the user from repeating it
-- Novel: it adds a distinct fact to this checkpoint
-- Important: losing it would cause rework or discard a preference or rule
-- Persistent: it is expected to remain useful for at least two weeks
-
-Assign each retained fact its best current mark:
-- `[permanent]` for core preferences, personal traits, and habits that remain relevant indefinitely
-- `[durable]` for technical discoveries, project knowledge, and configuration that remains valid for months
-- `[ephemeral]` for active task state and temporary decisions that may change within weeks
-- `[correction]` for the current fact that supersedes conflicting earlier long-term memory
-
-When space is limited, prioritize user corrections and preferences, then solutions, decisions, events, and environment facts.
-
-## Output
-
-Return one concise retained fact per line in this form:
-- [mark] fact
-
-Use `(nothing)` when no fact qualifies and there is no active working state.
+Return only formatted fact lines, or `(nothing)` if nothing noteworthy happened.

nanobot/templates/agent/dream.md

@@ -99,7 +99,7 @@ For [SKILL] entries:
 - Skills are instruction sets with concrete values, commands, and examples. MEMORY.md keeps strategic context and high-level facts only.
 
 ## Editing
-- Current contents of SOUL.md, USER.md, and memory/MEMORY.md are provided by the agent system context. Edit those files directly; do not rely on a remembered version of a file.
+- Current contents of SOUL.md, USER.md, and memory/MEMORY.md are embedded in this prompt under "Current Memory Files". Edit those files directly; do not rely on a remembered version of a file.
 - Batch changes into as few calls as possible. Surgical edits only.
 
 ## Verification

nanobot/templates/agent/tool_contract.md

@@ -40,7 +40,7 @@
   result with its original consumer or checker when one is available.
 - Use `apply_patch` as the default code editing tool, especially for multi-file changes, structural edits, generated code, moves, adds, or deletes.
 - Use `apply_patch dry_run=true` when the patch is uncertain and you want validation plus a change summary before writing.
-- Use `edit_file` only for small exact replacements in one file, with `old_text` copied from `read_file`.
+- Use `edit_file` only for small exact replacements in one file, with `old_text` copied from `read_file`; when editing a specific numbered line, pass that exact line as `line_hint`; add `occurrence` or `expected_replacements` when ambiguity matters.
 - Use `write_file` for new files or intentional full-file rewrites, not routine partial edits.
 - If `apply_patch` or `edit_file` fails, re-read with `force=true`, narrow the context, and try a smaller patch rather than switching to shell `sed` or `echo`.
 

nanobot/webui/session_context.py

@@ -44,7 +44,7 @@ def session_context_payload(session: Session) -> dict[str, Any]:
         "schema_version": 1,
         "session_key": session.key,
         "total_messages": len(session.messages),
-        "archived_messages": min(session.last_archived, len(session.messages)),
+        "archived_messages": min(session.last_consolidated, len(session.messages)),
         "replay_messages": len(replay),
         "estimated_replay_tokens": replay_tokens,
         "estimated_summary_tokens": summary_tokens,

nanobot/webui/settings_api.py

@@ -269,11 +269,7 @@ def update_model_call_order(
     config_path: Path | None = None,
 ) -> dict[str, Any]:
     config = _load_settings_config(config_path)
-    if models.update_model_call_order(
-        config,
-        query,
-        oauth_status=_oauth_provider_status,
-    ):
+    if models.update_model_call_order(config, query):
         _save_settings_config(config, config_path)
     return settings_payload(config_path=config_path)
 
@@ -284,10 +280,7 @@ def migrate_model_configurations(
     config_path: Path | None = None,
 ) -> dict[str, Any]:
     config = _load_settings_config(config_path)
-    if models.migrate_model_configurations(
-        config,
-        oauth_status=_oauth_provider_status,
-    ):
+    if models.migrate_model_configurations(config):
         _save_settings_config(config, config_path)
     return settings_payload(config_path=config_path)
 

nanobot/webui/settings_models.py

@@ -28,10 +28,6 @@ from nanobot.config.loader import resolve_config_env_vars
 from nanobot.config.schema import Config, FallbackCandidate, ModelPresetConfig, ProviderConfig
 from nanobot.providers.image_generation import get_image_gen_provider
 from nanobot.providers.oauth_guidance import OAUTH_CLI_KIT_MISSING_MESSAGE
-from nanobot.providers.oauth_model_catalog import (
-    get_oauth_model_catalog,
-    invalidate_oauth_model_catalog,
-)
 from nanobot.providers.registry import PROVIDERS, create_dynamic_spec, find_by_name
 from nanobot.webui.settings_contracts import (
     QueryParams,
@@ -81,7 +77,6 @@ class ModelSettingsPayload(TypedDict):
     model_presets: list[dict[str, Any]]
     model_call_order: list[str]
     model_call_order_editable: bool
-    model_configuration_migratable: bool
     providers: list[dict[str, Any]]
 
 
@@ -666,30 +661,6 @@ def provider_models_payload(
             "models": rows,
             "model_count": len(rows),
         }
-    if catalog_kind == "hybrid":
-        proxy = _resolve_env_placeholders(provider_config.proxy)
-        catalog = get_oauth_model_catalog(spec.name, proxy=proxy)
-        rows = [
-            {
-                "id": model.id,
-                "label": model.label or None,
-                "description": model.description or None,
-                "owned_by": model.owned_by or spec.label,
-                "context_window": model.context_window,
-                "reasoning_efforts": list(model.reasoning_efforts),
-                "supports_backend_search": model.supports_backend_search,
-            }
-            for model in catalog.models
-        ]
-        return {
-            **base_payload,
-            "status": "available",
-            "source": catalog.source,
-            "models": rows,
-            "model_count": len(rows),
-            "message": catalog.message,
-            "fetched_at": catalog.fetched_at,
-        }
 
     api_base = _resolve_env_placeholders(provider_config.api_base) or spec.default_api_base
     if spec.name == "openai" and not api_base:
@@ -926,48 +897,6 @@ def _model_call_order_state(config: Config) -> tuple[list[str], bool]:
     return order, True
 
 
-def _legacy_model_configuration_migratable(
-    config: Config,
-    oauth_status: OAuthStatusReader,
-) -> bool:
-    """Return whether the implicit default represents usable legacy configuration.
-
-    A pristine config still carries schema defaults for backwards compatibility.
-    Those defaults are not user configuration and must not be materialized as a
-    preset. Inline fallbacks, or a default whose matching provider is configured,
-    are evidence that there is real legacy state to preserve.
-    """
-    _, editable = _model_call_order_state(config)
-    if editable:
-        return False
-
-    defaults = config.agents.defaults
-    if defaults.fallback_models:
-        return True
-
-    provider_name = defaults.provider
-    if provider_name == "auto":
-        model_prefix = defaults.model.split("/", 1)[0] if "/" in defaults.model else ""
-        if model_prefix and resolve_settings_provider(config, model_prefix) is not None:
-            provider_name = model_prefix
-        else:
-            provider_name = (
-                config.get_provider_name(
-                    defaults.model,
-                    preset=config.resolve_default_preset(),
-                )
-                or ""
-            )
-    if not provider_name or provider_name == "auto":
-        return False
-
-    resolved_provider = resolve_settings_provider(config, provider_name)
-    if resolved_provider is None:
-        return False
-    spec, _, provider_config = resolved_provider
-    return provider_configured_for_settings(spec, provider_config, oauth_status)
-
-
 def _validate_configured_provider(
     config: Config,
     provider: str,
@@ -1116,10 +1045,6 @@ def model_settings_payload(
         "model_presets": model_presets,
         "model_call_order": model_call_order,
         "model_call_order_editable": model_call_order_editable,
-        "model_configuration_migratable": _legacy_model_configuration_migratable(
-            config,
-            oauth_status,
-        ),
         "providers": providers,
     }
 
@@ -1200,10 +1125,6 @@ def create_model_configuration(
         raise WebUISettingsError("configuration already exists", status=409)
     _validate_configured_provider(config, provider, oauth_status)
 
-    activate_as_primary = not config.model_presets and not _legacy_model_configuration_migratable(
-        config, oauth_status
-    )
-
     base = config.resolve_preset()
     max_tokens = _parse_positive_int(
         query_first_alias(query, "max_tokens", "maxTokens"),
@@ -1231,9 +1152,6 @@ def create_model_configuration(
         temperature=temperature if temperature is not None else base.temperature,
         reasoning_effort=reasoning_effort,
     )
-    if activate_as_primary:
-        config.agents.defaults.model_preset = name
-        config.agents.defaults.fallback_models = []
     return name
 
 
@@ -1312,12 +1230,7 @@ def update_model_configuration(
     return changed
 
 
-def update_model_call_order(
-    config: Config,
-    query: QueryParams,
-    *,
-    oauth_status: OAuthStatusReader,
-) -> bool:
+def update_model_call_order(config: Config, query: QueryParams) -> bool:
     raw_order = query_first_alias(query, "order", "presetNames")
     if raw_order is None:
         raise WebUISettingsError("model call order is required")
@@ -1336,16 +1249,15 @@ def update_model_call_order(
         raise WebUISettingsError("model call order must contain at least one preset")
 
     normalized_order = [cast(str, name).strip() for name in cast(list[object], order)]
-    unknown = [name for name in normalized_order if name not in config.model_presets]
-    if unknown:
-        raise WebUISettingsError(f"unknown model preset: {unknown[0]}")
-
     _, editable = _model_call_order_state(config)
-    if not editable and _legacy_model_configuration_migratable(config, oauth_status):
+    if not editable:
         raise WebUISettingsError(
             "convert the existing model configuration to presets first",
             status=409,
         )
+    unknown = [name for name in normalized_order if name not in config.model_presets]
+    if unknown:
+        raise WebUISettingsError(f"unknown model preset: {unknown[0]}")
 
     defaults = config.agents.defaults
     fallback_models: list[FallbackCandidate] = list(normalized_order[1:])
@@ -1359,18 +1271,8 @@ def update_model_call_order(
     return changed
 
 
-def migrate_model_configurations(
-    config: Config,
-    *,
-    oauth_status: OAuthStatusReader,
-) -> bool:
+def migrate_model_configurations(config: Config) -> bool:
     """Materialize legacy primary/inline model settings as named presets."""
-    _, editable = _model_call_order_state(config)
-    if editable:
-        return False
-    if not _legacy_model_configuration_migratable(config, oauth_status):
-        raise WebUISettingsError("there is no legacy model configuration to convert", status=409)
-
     defaults = config.agents.defaults
     primary = config.resolve_preset()
     created: list[str] = []
@@ -1604,7 +1506,6 @@ def login_oauth_provider(
             token = login_github_copilot(print_fn=lambda _message: None)
         if not (token and token.access):
             raise WebUISettingsError("OAuth login failed", status=401)
-        invalidate_oauth_model_catalog(spec.name)
         return settings_payload(config_path=config_path)
 
     if spec.name == "xai_grok":
@@ -1690,7 +1591,6 @@ def complete_oauth_provider(
     oauth_flows.remove(spec.name, flow_id, flow, cancel=False)
     if not token.access:
         raise WebUISettingsError("OAuth login failed", status=401)
-    invalidate_oauth_model_catalog(spec.name)
     return settings_payload(config_path=config_path)
 
 
@@ -1729,7 +1629,6 @@ def logout_oauth_provider(
 
         oauth_flows.clear(spec.name)
         logout_xai_oauth()
-        invalidate_oauth_model_catalog(spec.name)
         return settings_payload(config_path=config_path)
     else:
         raise WebUISettingsError("OAuth logout is not supported for this provider")
@@ -1737,7 +1636,6 @@ def logout_oauth_provider(
     for path in (token_path, token_path.with_suffix(".lock")):
         with suppress(FileNotFoundError):
             path.unlink()
-    invalidate_oauth_model_catalog(spec.name)
     return settings_payload(config_path=config_path)
 
 

nanobot/webui/settings_system.py

@@ -114,6 +114,7 @@ def system_settings_payload(
             "heartbeat": {
                 "enabled": config.gateway.heartbeat.enabled,
                 "interval_s": config.gateway.heartbeat.interval_s,
+                "keep_recent_messages": config.gateway.heartbeat.keep_recent_messages,
             },
             "dream": {
                 "schedule": defaults.dream.describe_schedule(),

nanobot/webui/workspaces.py

@@ -357,7 +357,3 @@ class WebUIWorkspaceController:
         self._draft_scopes.move_to_end(session_key)
         while len(self._draft_scopes) > _MAX_DRAFT_SCOPES:
             self._draft_scopes.popitem(last=False)
-
-    def discard_draft_scope(self, session_key: str) -> bool:
-        """Discard the staged scope for a chat that has not persisted yet."""
-        return self._draft_scopes.pop(session_key, None) is not None

nanobot/webui/ws_http.py

@@ -952,12 +952,9 @@ class GatewayHTTPHandler:
                         self.local_trigger_store.delete(job.id)
                 elif self.cron_service is not None:
                     self.cron_service.remove_job(job.id)
-        draft_deleted = self.workspaces.discard_draft_scope(decoded_key)
         session_deleted = self.session_manager.delete_session(decoded_key)
         transcript_deleted = delete_webui_thread(decoded_key)
-        return _http_json_response(
-            {"deleted": bool(draft_deleted or session_deleted or transcript_deleted)}
-        )
+        return _http_json_response({"deleted": bool(session_deleted or transcript_deleted)})
 
     # -- Automation routes --------------------------------------------------
 

tests/agent/test_attachment_references.py

@@ -5,7 +5,6 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from nanobot.agent.context import TranscriptInput
 from nanobot.agent.loop import AgentLoop, TurnContext, TurnKind
 from nanobot.agent.tools.context import RequestContext
 from nanobot.agent.tools.filesystem import ReadFileTool
@@ -149,10 +148,7 @@ async def test_pending_document_attachment_keeps_body_out_of_prompt(
 
     runtime = loop.llm_runtime()
     result = await loop._run_agent_loop(
-        TranscriptInput(
-            history=[{"role": "user", "content": "hello"}],
-            current_message=None,
-        ),
+        [{"role": "user", "content": "hello"}],
         runtime=runtime,
         request_context=RequestContext(channel="cli", chat_id="c", runtime=runtime),
         pending_queue=pending_queue,

tests/agent/test_auto_compact.py

@@ -8,6 +8,7 @@ from unittest.mock import AsyncMock, MagicMock
 import pytest
 
 from nanobot.agent.loop import AgentLoop
+from nanobot.agent.runner import AgentRunResult
 from nanobot.agent.tools.registry import ToolRegistry
 from nanobot.bus.events import InboundMessage
 from nanobot.bus.queue import MessageBus
@@ -87,11 +88,11 @@ def _make_fake_compact(
         state["count"] += 1
         session = loop.sessions.get_or_create(key)
 
-        tail = list(session.messages[session.last_archived:])
+        tail = list(session.messages[session.last_consolidated:])
         if not tail:
             loop.sessions.save(session)
             return ""
-        archive_end = session.last_archived + len(tail)
+        archive_end = session.last_consolidated + len(tail)
         archive_msgs = tail
 
         last_active = session.updated_at
@@ -108,7 +109,7 @@ def _make_fake_compact(
                 "last_active": last_active.isoformat(),
             }
 
-        session.last_archived = archive_end
+        session.last_consolidated = archive_end
         loop.sessions.save(session)
         return s
 
@@ -228,6 +229,36 @@ class TestAgentLoopTTLParam:
         loop = _make_loop(tmp_path, session_ttl_minutes=0)
         assert loop.auto_compact._ttl == 0
 
+    @pytest.mark.asyncio
+    async def test_process_message_reads_history_with_token_budget(self, tmp_path):
+        """_process_message should pass an auto-derived token budget to get_history."""
+        loop = _make_loop(tmp_path)
+        session = loop.sessions.get_or_create("cli:direct")
+        session.get_history = MagicMock(return_value=[])
+        loop.context.build_messages = MagicMock(return_value=[])
+        loop._run_agent_loop = AsyncMock(
+            return_value=AgentRunResult(
+                final_content="ok",
+                messages=[],
+                stop_reason="stop",
+            )
+        )
+        loop._save_turn = MagicMock()
+
+        msg = InboundMessage(
+            channel="cli",
+            sender_id="u1",
+            chat_id="direct",
+            content="hello",
+        )
+        await loop._process_message(msg)
+        session.get_history.assert_called_once()
+        kwargs = session.get_history.call_args.kwargs
+        assert isinstance(kwargs.get("max_tokens"), int)
+        assert kwargs["max_tokens"] > 0
+        assert set(kwargs) == {"max_tokens", "extend_to_user"}
+
+
 class TestAutoCompact:
     """Test the _archive method."""
 
@@ -368,12 +399,12 @@ class TestAutoCompact:
         await loop.aclose()
 
     @pytest.mark.asyncio
-    async def test_auto_compact_respects_last_archived(self, tmp_path):
-        """_archive should process only unarchived messages."""
+    async def test_auto_compact_respects_last_consolidated(self, tmp_path):
+        """_archive should only archive un-consolidated messages."""
         loop = _make_loop(tmp_path, session_ttl_minutes=15)
         session = loop.sessions.get_or_create("cli:test")
         _add_turns(session, 14)
-        session.last_archived = 18
+        session.last_consolidated = 18
         loop.sessions.save(session)
 
         archived_messages = []
@@ -1271,9 +1302,9 @@ class TestSummaryPersistence:
         assert "_last_summary" in reloaded.metadata
 
         # Simulate /new command
-        reloaded.clear()
-        loop.sessions.save(reloaded)
-        loop.sessions.invalidate(reloaded.key)
+        session.clear()
+        loop.sessions.save(session)
+        loop.sessions.invalidate(session.key)
 
         # After /new, metadata should no longer contain _last_summary
         fresh = loop.sessions.get_or_create("cli:test")

tests/agent/test_autocompact_unit.py

@@ -16,7 +16,7 @@ def _runtime(_session: Session | None = None):
 def _make_session(
     key: str = "cli:test",
     messages: list | None = None,
-    last_archived: int = 0,
+    last_consolidated: int = 0,
     updated_at: datetime | None = None,
     metadata: dict | None = None,
 ) -> Session:
@@ -25,8 +25,8 @@ def _make_session(
         key=key,
         messages=messages or [],
         metadata=metadata or {},
+        last_consolidated=last_consolidated,
     )
-    session.last_archived = last_archived
     if updated_at is not None:
         session.updated_at = updated_at
     return session
@@ -408,7 +408,7 @@ class TestCheckExpired:
         last_active = datetime(2026, 1, 1, 10, 0, 0)
         session = _make_session("cli:done", updated_at=last_active)
         _add_turns(session, 2)
-        session.last_archived = len(session.messages)
+        session.last_consolidated = len(session.messages)
         mock_sm.list_sessions.return_value = [
             {"key": "cli:done", "updated_at": last_active.isoformat()},
         ]

tests/agent/test_consolidate_offset.py

@@ -0,0 +1,650 @@
+"""Test session management with cache-friendly message handling."""
+
+import asyncio
+from collections.abc import Coroutine
+from pathlib import Path
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from nanobot.session.manager import Session, SessionManager
+
+# Test constants
+MEMORY_WINDOW = 50
+KEEP_COUNT = MEMORY_WINDOW // 2  # 25
+
+
+def create_session_with_messages(key: str, count: int, role: str = "user") -> Session:
+    """Create a session and add the specified number of messages.
+
+    Args:
+        key: Session identifier
+        count: Number of messages to add
+        role: Message role (default: "user")
+
+    Returns:
+        Session with the specified messages
+    """
+    session = Session(key=key)
+    for i in range(count):
+        session.add_message(role, f"msg{i}")
+    return session
+
+
+def assert_messages_content(messages: list, start_index: int, end_index: int) -> None:
+    """Assert that messages contain expected content from start to end index.
+
+    Args:
+        messages: List of message dictionaries
+        start_index: Expected first message index
+        end_index: Expected last message index
+    """
+    assert len(messages) > 0
+    assert messages[0]["content"] == f"msg{start_index}"
+    assert messages[-1]["content"] == f"msg{end_index}"
+
+
+def get_old_messages(session: Session, last_consolidated: int, keep_count: int) -> list:
+    """Extract messages that would be consolidated using the standard slice logic.
+
+    Args:
+        session: The session containing messages
+        last_consolidated: Index of last consolidated message
+        keep_count: Number of recent messages to keep
+
+    Returns:
+        List of messages that would be consolidated
+    """
+    return session.messages[last_consolidated:-keep_count]
+
+
+class TestSessionLastConsolidated:
+    """Test last_consolidated tracking to avoid duplicate processing."""
+
+    def test_initial_last_consolidated_zero(self) -> None:
+        """Test that new session starts with last_consolidated=0."""
+        session = Session(key="test:initial")
+        assert session.last_consolidated == 0
+
+    def test_last_consolidated_persistence(self, tmp_path) -> None:
+        """Test that last_consolidated persists across save/load."""
+        manager = SessionManager(Path(tmp_path))
+        session1 = create_session_with_messages("test:persist", 20)
+        session1.last_consolidated = 15
+        manager.save(session1)
+
+        session2 = manager.get_or_create("test:persist")
+        assert session2.last_consolidated == 15
+        assert len(session2.messages) == 20
+
+    def test_clear_resets_last_consolidated(self) -> None:
+        """Test that clear() resets last_consolidated to 0."""
+        session = create_session_with_messages("test:clear", 10)
+        session.last_consolidated = 5
+
+        session.clear()
+        assert len(session.messages) == 0
+        assert session.last_consolidated == 0
+
+
+class TestSessionImmutableHistory:
+    """Test Session message immutability for cache efficiency."""
+
+    def test_initial_state(self) -> None:
+        """Test that new session has empty messages list."""
+        session = Session(key="test:initial")
+        assert len(session.messages) == 0
+
+    def test_add_messages_appends_only(self) -> None:
+        """Test that adding messages only appends, never modifies."""
+        session = Session(key="test:preserve")
+        session.add_message("user", "msg1")
+        session.add_message("assistant", "resp1")
+        session.add_message("user", "msg2")
+        assert len(session.messages) == 3
+        assert session.messages[0]["content"] == "msg1"
+
+    def test_get_history_returns_most_recent(self) -> None:
+        """Test get_history returns the most recent messages."""
+        session = Session(key="test:history")
+        for i in range(10):
+            session.add_message("user", f"msg{i}")
+            session.add_message("assistant", f"resp{i}")
+
+        history = session.get_history(max_messages=6)
+        assert len(history) == 6
+        assert history[0]["content"] == "msg7"
+        assert history[-1]["content"] == "resp9"
+
+    def test_get_history_with_all_messages(self) -> None:
+        """Test get_history with max_messages larger than actual."""
+        session = create_session_with_messages("test:all", 5)
+        history = session.get_history(max_messages=100)
+        assert len(history) == 5
+        assert history[0]["content"] == "msg0"
+
+    def test_get_history_stable_for_same_session(self) -> None:
+        """Test that get_history returns same content for same max_messages."""
+        session = create_session_with_messages("test:stable", 20)
+        history1 = session.get_history(max_messages=10)
+        history2 = session.get_history(max_messages=10)
+        assert history1 == history2
+
+    def test_messages_list_never_modified(self) -> None:
+        """Test that messages list is never modified after creation."""
+        session = create_session_with_messages("test:immutable", 5)
+        original_len = len(session.messages)
+
+        session.get_history(max_messages=2)
+        assert len(session.messages) == original_len
+
+        for _ in range(10):
+            session.get_history(max_messages=3)
+        assert len(session.messages) == original_len
+
+
+class TestSessionPersistence:
+    """Test Session persistence and reload."""
+
+    @pytest.fixture
+    def temp_manager(self, tmp_path):
+        return SessionManager(Path(tmp_path))
+
+    def test_persistence_roundtrip(self, temp_manager):
+        """Test that messages persist across save/load."""
+        session1 = create_session_with_messages("test:persistence", 20)
+        temp_manager.save(session1)
+
+        session2 = temp_manager.get_or_create("test:persistence")
+        assert len(session2.messages) == 20
+        assert session2.messages[0]["content"] == "msg0"
+        assert session2.messages[-1]["content"] == "msg19"
+
+    def test_get_history_after_reload(self, temp_manager):
+        """Test that get_history works correctly after reload."""
+        session1 = create_session_with_messages("test:reload", 30)
+        temp_manager.save(session1)
+
+        session2 = temp_manager.get_or_create("test:reload")
+        history = session2.get_history(max_messages=10)
+        assert len(history) == 10
+        assert history[0]["content"] == "msg20"
+        assert history[-1]["content"] == "msg29"
+
+    def test_clear_resets_session(self, temp_manager):
+        """Test that clear() properly resets session."""
+        session = create_session_with_messages("test:clear", 10)
+        assert len(session.messages) == 10
+
+        session.clear()
+        assert len(session.messages) == 0
+
+
+class TestConsolidationTriggerConditions:
+    """Test consolidation trigger conditions and logic."""
+
+    def test_consolidation_needed_when_messages_exceed_window(self):
+        """Test consolidation logic: should trigger when messages exceed the window."""
+        session = create_session_with_messages("test:trigger", 60)
+
+        total_messages = len(session.messages)
+        messages_to_process = total_messages - session.last_consolidated
+
+        assert total_messages > MEMORY_WINDOW
+        assert messages_to_process > 0
+
+        expected_consolidate_count = total_messages - KEEP_COUNT
+        assert expected_consolidate_count == 35
+
+    def test_consolidation_skipped_when_within_keep_count(self):
+        """Test consolidation skipped when total messages <= keep_count."""
+        session = create_session_with_messages("test:skip", 20)
+
+        total_messages = len(session.messages)
+        assert total_messages <= KEEP_COUNT
+
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        assert len(old_messages) == 0
+
+    def test_consolidation_skipped_when_no_new_messages(self):
+        """Test consolidation skipped when messages_to_process <= 0."""
+        session = create_session_with_messages("test:already_consolidated", 40)
+        session.last_consolidated = len(session.messages) - KEEP_COUNT  # 15
+
+        # Add a few more messages
+        for i in range(40, 42):
+            session.add_message("user", f"msg{i}")
+
+        total_messages = len(session.messages)
+        messages_to_process = total_messages - session.last_consolidated
+        assert messages_to_process > 0
+
+        # Simulate last_consolidated catching up
+        session.last_consolidated = total_messages - KEEP_COUNT
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        assert len(old_messages) == 0
+
+
+class TestLastConsolidatedEdgeCases:
+    """Test last_consolidated edge cases and data corruption scenarios."""
+
+    def test_last_consolidated_exceeds_message_count(self):
+        """Test behavior when last_consolidated > len(messages) (data corruption)."""
+        session = create_session_with_messages("test:corruption", 10)
+        session.last_consolidated = 20
+
+        total_messages = len(session.messages)
+        messages_to_process = total_messages - session.last_consolidated
+        assert messages_to_process <= 0
+
+        old_messages = get_old_messages(session, session.last_consolidated, 5)
+        assert len(old_messages) == 0
+
+    def test_last_consolidated_negative_value(self):
+        """Test behavior with negative last_consolidated (invalid state)."""
+        session = create_session_with_messages("test:negative", 10)
+        session.last_consolidated = -5
+
+        keep_count = 3
+        old_messages = get_old_messages(session, session.last_consolidated, keep_count)
+
+        # messages[-5:-3] with 10 messages gives indices 5,6
+        assert len(old_messages) == 2
+        assert old_messages[0]["content"] == "msg5"
+        assert old_messages[-1]["content"] == "msg6"
+
+    def test_messages_added_after_consolidation(self):
+        """Test correct behavior when new messages arrive after consolidation."""
+        session = create_session_with_messages("test:new_messages", 40)
+        session.last_consolidated = len(session.messages) - KEEP_COUNT  # 15
+
+        # Add new messages after consolidation
+        for i in range(40, 50):
+            session.add_message("user", f"msg{i}")
+
+        total_messages = len(session.messages)
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        expected_consolidate_count = total_messages - KEEP_COUNT - session.last_consolidated
+
+        assert len(old_messages) == expected_consolidate_count
+        assert_messages_content(old_messages, 15, 24)
+
+    def test_slice_behavior_when_indices_overlap(self):
+        """Test slice behavior when last_consolidated >= total - keep_count."""
+        session = create_session_with_messages("test:overlap", 30)
+        session.last_consolidated = 12
+
+        old_messages = get_old_messages(session, session.last_consolidated, 20)
+        assert len(old_messages) == 0
+
+
+class TestArchiveAllMode:
+    """Test archive_all mode (used by /new command)."""
+
+    def test_archive_all_consolidates_everything(self):
+        """Test archive_all=True consolidates all messages."""
+        session = create_session_with_messages("test:archive_all", 50)
+
+        archive_all = True
+        if archive_all:
+            old_messages = session.messages
+            assert len(old_messages) == 50
+
+        assert session.last_consolidated == 0
+
+    def test_archive_all_resets_last_consolidated(self):
+        """Test that archive_all mode resets last_consolidated to 0."""
+        session = create_session_with_messages("test:reset", 40)
+        session.last_consolidated = 15
+
+        archive_all = True
+        if archive_all:
+            session.last_consolidated = 0
+
+        assert session.last_consolidated == 0
+        assert len(session.messages) == 40
+
+    def test_archive_all_vs_normal_consolidation(self):
+        """Test difference between archive_all and normal consolidation."""
+        # Normal consolidation
+        session1 = create_session_with_messages("test:normal", 60)
+        session1.last_consolidated = len(session1.messages) - KEEP_COUNT
+
+        # archive_all mode
+        session2 = create_session_with_messages("test:all", 60)
+        session2.last_consolidated = 0
+
+        assert session1.last_consolidated == 35
+        assert len(session1.messages) == 60
+        assert session2.last_consolidated == 0
+        assert len(session2.messages) == 60
+
+
+class TestCacheImmutability:
+    """Test that consolidation doesn't modify session.messages (cache safety)."""
+
+    def test_consolidation_does_not_modify_messages_list(self):
+        """Test that consolidation leaves messages list unchanged."""
+        session = create_session_with_messages("test:immutable", 50)
+
+        original_messages = session.messages.copy()
+        original_len = len(session.messages)
+        session.last_consolidated = original_len - KEEP_COUNT
+
+        assert len(session.messages) == original_len
+        assert session.messages == original_messages
+
+    def test_get_history_does_not_modify_messages(self):
+        """Test that get_history doesn't modify messages list."""
+        session = create_session_with_messages("test:history_immutable", 40)
+        original_messages = [m.copy() for m in session.messages]
+
+        for _ in range(5):
+            history = session.get_history(max_messages=10)
+            assert len(history) == 10
+
+        assert len(session.messages) == 40
+        for i, msg in enumerate(session.messages):
+            assert msg["content"] == original_messages[i]["content"]
+
+    def test_consolidation_only_updates_last_consolidated(self):
+        """Test that consolidation only updates last_consolidated field."""
+        session = create_session_with_messages("test:field_only", 60)
+
+        original_messages = session.messages.copy()
+        original_key = session.key
+        original_metadata = session.metadata.copy()
+
+        session.last_consolidated = len(session.messages) - KEEP_COUNT
+
+        assert session.messages == original_messages
+        assert session.key == original_key
+        assert session.metadata == original_metadata
+        assert session.last_consolidated == 35
+
+
+class TestSliceLogic:
+    """Test the slice logic: messages[last_consolidated:-keep_count]."""
+
+    def test_slice_extracts_correct_range(self):
+        """Test that slice extracts the correct message range."""
+        session = create_session_with_messages("test:slice", 60)
+
+        old_messages = get_old_messages(session, 0, KEEP_COUNT)
+
+        assert len(old_messages) == 35
+        assert_messages_content(old_messages, 0, 34)
+
+        remaining = session.messages[-KEEP_COUNT:]
+        assert len(remaining) == 25
+        assert_messages_content(remaining, 35, 59)
+
+    def test_slice_with_partial_consolidation(self):
+        """Test slice when some messages already consolidated."""
+        session = create_session_with_messages("test:partial", 70)
+
+        last_consolidated = 30
+        old_messages = get_old_messages(session, last_consolidated, KEEP_COUNT)
+
+        assert len(old_messages) == 15
+        assert_messages_content(old_messages, 30, 44)
+
+    def test_slice_with_various_keep_counts(self):
+        """Test slice behavior with different keep_count values."""
+        session = create_session_with_messages("test:keep_counts", 50)
+
+        test_cases = [(10, 40), (20, 30), (30, 20), (40, 10)]
+
+        for keep_count, expected_count in test_cases:
+            old_messages = session.messages[0:-keep_count]
+            assert len(old_messages) == expected_count
+
+    def test_slice_when_keep_count_exceeds_messages(self):
+        """Test slice when keep_count > len(messages)."""
+        session = create_session_with_messages("test:exceed", 10)
+
+        old_messages = session.messages[0:-20]
+        assert len(old_messages) == 0
+
+
+class TestEmptyAndBoundarySessions:
+    """Test empty sessions and boundary conditions."""
+
+    def test_empty_session_consolidation(self):
+        """Test consolidation behavior with empty session."""
+        session = Session(key="test:empty")
+
+        assert len(session.messages) == 0
+        assert session.last_consolidated == 0
+
+        messages_to_process = len(session.messages) - session.last_consolidated
+        assert messages_to_process == 0
+
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        assert len(old_messages) == 0
+
+    def test_single_message_session(self):
+        """Test consolidation with single message."""
+        session = Session(key="test:single")
+        session.add_message("user", "only message")
+
+        assert len(session.messages) == 1
+
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        assert len(old_messages) == 0
+
+    def test_exactly_keep_count_messages(self):
+        """Test session with exactly keep_count messages."""
+        session = create_session_with_messages("test:exact", KEEP_COUNT)
+
+        assert len(session.messages) == KEEP_COUNT
+
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        assert len(old_messages) == 0
+
+    def test_just_over_keep_count(self):
+        """Test session with one message over keep_count."""
+        session = create_session_with_messages("test:over", KEEP_COUNT + 1)
+
+        assert len(session.messages) == 26
+
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        assert len(old_messages) == 1
+        assert old_messages[0]["content"] == "msg0"
+
+    def test_very_large_session(self):
+        """Test consolidation with very large message count."""
+        session = create_session_with_messages("test:large", 1000)
+
+        assert len(session.messages) == 1000
+
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+        assert len(old_messages) == 975
+        assert_messages_content(old_messages, 0, 974)
+
+        remaining = session.messages[-KEEP_COUNT:]
+        assert len(remaining) == 25
+        assert_messages_content(remaining, 975, 999)
+
+    def test_session_with_gaps_in_consolidation(self):
+        """Test session with potential gaps in consolidation history."""
+        session = create_session_with_messages("test:gaps", 50)
+        session.last_consolidated = 10
+
+        # Add more messages
+        for i in range(50, 60):
+            session.add_message("user", f"msg{i}")
+
+        old_messages = get_old_messages(session, session.last_consolidated, KEEP_COUNT)
+
+        expected_count = 60 - KEEP_COUNT - 10
+        assert len(old_messages) == expected_count
+        assert_messages_content(old_messages, 10, 34)
+
+
+class TestNewCommandArchival:
+    """Test /new archival behavior with the simplified consolidation flow."""
+
+    @staticmethod
+    def _make_loop(tmp_path: Path):
+        from nanobot.agent.loop import AgentLoop
+        from nanobot.bus.queue import MessageBus
+        from nanobot.providers.base import GenerationSettings, LLMResponse
+
+        bus = MessageBus()
+        provider = MagicMock()
+        provider.get_default_model.return_value = "test-model"
+        provider.estimate_prompt_tokens.return_value = (10_000, "test")
+        provider.generation = GenerationSettings(max_tokens=100)
+        loop = AgentLoop(
+            bus=bus,
+            provider=provider,
+            workspace=tmp_path,
+            model="test-model",
+            context_window_tokens=1,
+        )
+        loop.provider.chat_with_retry = AsyncMock(return_value=LLMResponse(content="ok", tool_calls=[]))
+        loop.tools.get_definitions = MagicMock(return_value=[])
+        return loop
+
+    @pytest.mark.asyncio
+    async def test_new_clears_session_immediately_even_if_archive_fails(self, tmp_path: Path) -> None:
+        """/new clears session immediately; archive is fire-and-forget."""
+        from nanobot.bus.events import InboundMessage
+
+        loop = self._make_loop(tmp_path)
+        session = loop.sessions.get_or_create("cli:test")
+        for i in range(5):
+            session.add_message("user", f"msg{i}")
+            session.add_message("assistant", f"resp{i}")
+        loop.sessions.save(session)
+
+        call_count = 0
+        expected_runtime = loop.llm_runtime()
+
+        async def _failing_summarize(session, *, archive_end, runtime) -> None:
+            nonlocal call_count
+            assert runtime is expected_runtime
+            assert session.key == "cli:test"
+            assert archive_end == len(session.messages)
+            call_count += 1
+
+        loop.consolidator.archive_session = _failing_summarize  # type: ignore[method-assign]
+
+        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
+        response = await loop._process_message(new_msg, runtime=expected_runtime)
+
+        assert response is not None
+        assert "new session started" in response.content.lower()
+
+        session_after = loop.sessions.get_or_create("cli:test")
+        assert len(session_after.messages) == 0
+
+        await loop.aclose()
+        assert call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_new_reuses_replay_prefix_and_archives_only_unconsolidated_messages(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        from nanobot.bus.events import InboundMessage
+
+        loop = self._make_loop(tmp_path)
+        loop.set_runtime_context_window(128_000)
+        session = loop.sessions.get_or_create("cli:test")
+        for i in range(5):
+            session.add_message("user", f"msg{i}")
+            session.add_message("assistant", f"resp{i}")
+        session.last_consolidated = len(session.messages) - 2
+        ordinary_history = session.get_history()
+        assert [message["content"] for message in ordinary_history] == [
+            "msg1",
+            "resp1",
+            "msg2",
+            "resp2",
+            "msg3",
+            "resp3",
+            "msg4",
+            "resp4",
+        ]
+        loop.sessions.save(session)
+
+        expected_runtime = loop.llm_runtime()
+        scheduled: list[Coroutine[Any, Any, object]] = []
+        loop.schedule_background = scheduled.append  # type: ignore[method-assign]
+
+        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
+        response = await loop._process_message(new_msg, runtime=expected_runtime)
+
+        assert response is not None
+        assert "new session started" in response.content.lower()
+
+        assert len(scheduled) == 1
+        await scheduled[0]
+        await loop.aclose()
+        sent = loop.provider.chat_with_retry.call_args.kwargs["messages"]
+        assert sent[1:-1] == ordinary_history
+        assert "final 2 conversation messages" in sent[-1]["content"]
+
+    @pytest.mark.asyncio
+    async def test_new_clears_session_and_responds(self, tmp_path: Path) -> None:
+        from nanobot.bus.events import InboundMessage
+
+        loop = self._make_loop(tmp_path)
+        session = loop.sessions.get_or_create("cli:test")
+        for i in range(3):
+            session.add_message("user", f"msg{i}")
+            session.add_message("assistant", f"resp{i}")
+        loop.sessions.save(session)
+        expected_runtime = loop.llm_runtime()
+
+        async def _ok_summarize(session, *, archive_end, runtime) -> str:
+            assert runtime is expected_runtime
+            assert session.key == "cli:test"
+            assert archive_end == len(session.messages)
+            return "Summary."
+
+        loop.consolidator.archive_session = _ok_summarize  # type: ignore[method-assign]
+
+        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
+        response = await loop._process_message(new_msg, runtime=expected_runtime)
+
+        assert response is not None
+        assert "new session started" in response.content.lower()
+        assert loop.sessions.get_or_create("cli:test").messages == []
+
+    @pytest.mark.asyncio
+    async def test_aclose_drains_background_tasks(self, tmp_path: Path) -> None:
+        """aclose waits for background tasks to complete."""
+        from nanobot.bus.events import InboundMessage
+
+        loop = self._make_loop(tmp_path)
+        session = loop.sessions.get_or_create("cli:test")
+        for i in range(3):
+            session.add_message("user", f"msg{i}")
+            session.add_message("assistant", f"resp{i}")
+        loop.sessions.save(session)
+
+        archived = asyncio.Event()
+        release_archive = asyncio.Event()
+        expected_runtime = loop.llm_runtime()
+
+        async def _slow_summarize(session, *, archive_end, runtime) -> str:
+            assert runtime is expected_runtime
+            assert session.key == "cli:test"
+            assert archive_end == len(session.messages)
+            await release_archive.wait()
+            archived.set()
+            return "Summary."
+
+        loop.consolidator.archive_session = _slow_summarize  # type: ignore[method-assign]
+
+        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
+        await loop._process_message(new_msg, runtime=expected_runtime)
+
+        assert not archived.is_set()
+        release_archive.set()
+        await loop.aclose()
+        assert archived.is_set()

tests/agent/test_consolidation_ratio.py

@@ -0,0 +1,112 @@
+"""Tests for configurable consolidation_ratio."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pydantic import ValidationError
+
+import nanobot.agent.memory as memory_module
+from nanobot.agent.loop import AgentLoop
+from nanobot.bus.queue import MessageBus
+from nanobot.config.schema import AgentDefaults
+from nanobot.providers.base import GenerationSettings, LLMResponse
+
+
+def _make_loop(
+    tmp_path,
+    *,
+    estimated_tokens: int = 0,
+    context_window_tokens: int = 200,
+    consolidation_ratio: float = 0.5,
+) -> AgentLoop:
+    provider = MagicMock()
+    provider.get_default_model.return_value = "test-model"
+    provider.generation = GenerationSettings(max_tokens=0)
+    provider.estimate_prompt_tokens.return_value = (estimated_tokens, "test-counter")
+    _response = LLMResponse(content="ok", tool_calls=[])
+    provider.chat_with_retry = AsyncMock(return_value=_response)
+    provider.chat_stream_with_retry = AsyncMock(return_value=_response)
+
+    loop = AgentLoop(
+        bus=MessageBus(),
+        provider=provider,
+        workspace=tmp_path,
+        model="test-model",
+        context_window_tokens=context_window_tokens,
+        consolidation_ratio=consolidation_ratio,
+    )
+    loop.tools.get_definitions = MagicMock(return_value=[])
+    loop.consolidator._SAFETY_BUFFER = 0
+    return loop
+
+
+def _session_with_turns(loop: AgentLoop, *, turns: int):
+    session = loop.sessions.get_or_create("cli:test")
+    session.messages = []
+    for i in range(turns):
+        session.messages.append({"role": "user", "content": f"u{i}", "timestamp": f"2026-01-01T00:00:{i:02d}"})
+        session.messages.append({"role": "assistant", "content": f"a{i}", "timestamp": f"2026-01-01T00:01:{i:02d}"})
+    loop.sessions.save(session)
+    return session
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("ratio", "context_window_tokens", "estimates", "expected_archives"),
+    [
+        (0.5, 200, [250, 90], 1),
+        (0.1, 1000, [1200, 800, 400, 50], 2),
+        (0.9, 200, [300, 175], 1),
+    ],
+)
+async def test_consolidation_ratio_controls_target(
+    tmp_path,
+    monkeypatch,
+    ratio: float,
+    context_window_tokens: int,
+    estimates: list[int],
+    expected_archives: int,
+) -> None:
+    loop = _make_loop(
+        tmp_path,
+        context_window_tokens=context_window_tokens,
+        consolidation_ratio=ratio,
+    )
+    loop.consolidator.archive_session = AsyncMock(return_value=True)  # type: ignore[method-assign]
+    session = _session_with_turns(loop, turns=10)
+
+    remaining_estimates = list(estimates)
+
+    runtime = loop.llm_runtime()
+
+    def mock_estimate(_session, *, runtime):
+        return (remaining_estimates.pop(0), "test")
+
+    loop.consolidator.estimate_session_prompt_tokens = mock_estimate  # type: ignore[method-assign]
+    monkeypatch.setattr(memory_module, "estimate_message_tokens", lambda _m: 100)
+
+    await loop.consolidator.maybe_consolidate_by_tokens(
+        session,
+        runtime=runtime,
+    )
+
+    assert loop.consolidator.archive_session.await_count == expected_archives
+
+
+def test_ratio_propagated_from_config_schema() -> None:
+    defaults = AgentDefaults()
+    assert defaults.consolidation_ratio == 0.5
+
+    defaults = AgentDefaults.model_validate({"consolidationRatio": 0.3})
+    assert defaults.consolidation_ratio == 0.3
+
+    dumped = defaults.model_dump(by_alias=True)
+    assert dumped["consolidationRatio"] == 0.3
+
+
+def test_ratio_validation_rejects_out_of_range() -> None:
+    with pytest.raises(ValidationError):
+        AgentDefaults(consolidation_ratio=0.05)
+
+    with pytest.raises(ValidationError):
+        AgentDefaults(consolidation_ratio=1.0)

tests/agent/test_consolidator.py

@@ -1,4 +1,4 @@
-"""Tests for Memory checkpoint consolidation and history journaling."""
+"""Tests for the lightweight Consolidator — append-only to HISTORY.md."""
 
 from dataclasses import replace
 from unittest.mock import AsyncMock, MagicMock
@@ -6,7 +6,7 @@ from unittest.mock import AsyncMock, MagicMock
 import pytest
 
 from nanobot.agent.memory import (
-    _HISTORY_ENTRY_HARD_CAP,
+    _ARCHIVE_SUMMARY_MAX_CHARS,
     Consolidator,
     MemoryStore,
 )
@@ -26,8 +26,6 @@ from nanobot.session.manager import Session
 from nanobot.utils.llm_runtime import LLMRuntime
 from nanobot.utils.prompt_templates import render_template
 
-_ARCHIVE_PROMPT = render_template("agent/consolidator_archive.md", strip=True)
-
 
 @pytest.fixture
 def store(tmp_path):
@@ -55,7 +53,9 @@ def runtime(mock_provider):
 def consolidator(store):
     sessions = MagicMock()
     sessions.save = MagicMock()
-    # Store sessions by key so refreshes observe the same test object.
+    # When maybe_consolidate_by_tokens refreshes the session reference via
+    # get_or_create(session.key), it should get back the same object the test
+    # passed in.  Store sessions by key so the lookup is transparent.
     _session_cache: dict[str, MagicMock] = {}
     sessions.get_or_create = MagicMock(side_effect=lambda key: _session_cache.get(key, MagicMock()))
     sessions._session_cache = _session_cache
@@ -91,110 +91,26 @@ def _provider_state() -> ProviderConversationState:
 
 
 def _build_test_messages(**kwargs):
-    system = "system prompt"
-    session_summary = kwargs.get("session_summary")
-    if session_summary:
-        system += f"\n\n[Archived Context Summary]\n{session_summary['text']}"
-    messages = [
-        {"role": "system", "content": system},
+    return [
+        {"role": "system", "content": "system prompt"},
         *kwargs["history"],
+        {"role": "user", "content": kwargs["current_message"]},
     ]
-    if kwargs["current_message"] is not None:
-        messages.append({"role": "user", "content": kwargs["current_message"]})
-    return messages
 
 
-async def _archive(
-    consolidator,
-    messages,
-    runtime,
-    *,
-    session_key="test:session",
-    previous_summary=None,
-):
-    return await consolidator.archiver.archive(
+async def _archive(consolidator, messages, runtime, *, session_key="test:session"):
+    return await consolidator.archive(
         messages,
         runtime=runtime,
         session_key=session_key,
-        history=[
-            {"role": "system", "content": "system prompt"},
-            *messages,
-        ],
+        request_messages=_build_test_messages(
+            history=messages,
+            current_message="consolidate",
+        ),
         request_tools=[],
-        previous_summary=previous_summary,
     )
 
 
-class TestTurnTranscriptSummary:
-    async def test_uses_exact_accepted_prefix_and_existing_archiver(
-        self,
-        consolidator,
-        mock_provider,
-        runtime,
-    ):
-        accepted = [
-            {"role": "system", "content": "stable system"},
-            {"role": "user", "content": "accepted history"},
-        ]
-        tools = [{"type": "function", "function": {"name": "inspect"}}]
-        mock_provider.chat_with_retry.return_value = LLMResponse(
-            content="replacement checkpoint",
-        )
-
-        summary = await consolidator.summarize_transcript(
-            accepted,
-            "previous checkpoint",
-            runtime=runtime,
-            session_key="test:turn",
-            tools=tools,
-        )
-
-        assert summary == "replacement checkpoint"
-        call = mock_provider.chat_with_retry.await_args.kwargs
-        assert call["messages"][:-1] == accepted
-        assert call["messages"][-1]["role"] == "user"
-        assert "SNIP" in call["messages"][-1]["content"]
-        assert call["tools"] == tools
-
-    async def test_native_compaction_appends_only_archive_prompt(
-        self,
-        consolidator,
-        mock_provider,
-        runtime,
-    ):
-        accepted = [
-            {"role": "system", "content": "stable system"},
-            {"role": "user", "content": "raw history must not be replayed"},
-        ]
-        state = _provider_state()
-        mock_provider.can_resume_conversation_state.return_value = True
-        mock_provider.chat_with_retry.return_value = LLMResponse(
-            content="replacement checkpoint",
-        )
-
-        summary = await consolidator.summarize_provider_compaction(
-            state,
-            accepted,
-            "previous checkpoint",
-            runtime=runtime,
-            session_key="test:turn",
-            tools=[{"type": "function", "function": {"name": "inspect"}}],
-        )
-
-        assert summary == "replacement checkpoint"
-        call = mock_provider.chat_with_retry.await_args.kwargs
-        assert call["messages"][0] == accepted[0]
-        assert call["messages"][-1]["content"] == _ARCHIVE_PROMPT
-        assert accepted[1] not in call["messages"]
-        assert call["tools"] == []
-        provider_context = call["provider_context"]
-        assert provider_context.conversation_state is not None
-        assert provider_context.conversation_state.payload == state.payload
-        assert provider_context.conversation_state.pending_messages == [
-            call["messages"][-1],
-        ]
-
-
 class TestConsolidatorSummarize:
     def test_format_messages_keeps_media_only_user_turn(self):
         path = "/home/user/.nanobot/media/websocket/clip.mp4"
@@ -285,9 +201,7 @@ class TestConsolidatorSummarize:
         mock_provider.chat_with_retry.side_effect = Exception("API error")
         messages = [{"role": "user", "content": "hello"}]
         result = await _archive(consolidator, messages, runtime)
-        assert result is not None
-        assert "[RAW]" in result
-        assert "hello" in result
+        assert result is None  # no summary on raw dump fallback
         entries = store.read_unprocessed_history(since_cursor=0)
         assert len(entries) == 1
         assert "[RAW]" in entries[0]["content"]
@@ -312,52 +226,22 @@ class TestConsolidatorSummarize:
         entries = store.read_unprocessed_history(since_cursor=0)
         assert entries[0]["session_key"] == "slack:chat-2"
 
-    async def test_raw_fallback_represents_previous_checkpoint_and_new_chunk(
-        self,
-        consolidator,
-        mock_provider,
-        runtime,
-    ):
-        runtime = replace(runtime, generation=GenerationSettings(max_tokens=96))
-        mock_provider.chat_with_retry.side_effect = RuntimeError("API error")
-
-        result = await _archive(
-            consolidator,
-            [{"role": "user", "content": "NEW_MARKER " + "new " * 200}],
-            runtime,
-            previous_summary="OLD_MARKER " + "old " * 200,
-        )
-
-        assert result is not None
-        assert "[Previous archived context]" in result
-        assert "OLD_MARKER" in result
-        assert "[Newly archived raw context]" in result
-        assert "NEW_MARKER" in result
-        assert "... (truncated)" in result
-
     async def test_summarize_skips_empty_messages(self, consolidator, runtime):
         result = await _archive(consolidator, [], runtime)
         assert result is None
 
 
 class TestConsolidatorPromptContract:
-    def test_archive_prompt_requests_a_cumulative_replacement_checkpoint(self):
-        prompt = _ARCHIVE_PROMPT
+    def test_archive_prompt_outputs_attribute_tags_without_missing_context_claims(self):
+        prompt = render_template("agent/consolidator_archive.md", strip=True, archive_count=4)
 
-        for section in ("## Merge rules", "## What to retain", "## Output"):
-            assert section in prompt
-        assert "replacement checkpoint" in prompt
-        assert "[Archived Context Summary]" in prompt
-        assert "current conversation state" in prompt
         assert "SNIP" in prompt
-        for mark in ("[permanent]", "[durable]", "[ephemeral]", "[correction]"):
+        assert "final 4 conversation messages" in prompt
+        for mark in ("[permanent]", "[durable]", "[ephemeral]", "[correction]", "[skip]"):
             assert mark in prompt
-        assert "working-state handoff" in prompt
-        assert "- [mark] fact" in prompt
-        assert "[skip]" not in prompt
-        assert "(nothing)" in prompt
-        assert "history.jsonl" not in prompt
-
+        assert "check context below" not in prompt.lower()
+        assert "Do not output facts already present in the system prompt's Recent History" in prompt
+        assert "Do not mark something [skip] merely because it might already exist" in prompt
 
 class TestConsolidatorArchiveErrorHandling:
     """archive() must fall back when the LLM does not complete its overview.
@@ -386,8 +270,7 @@ class TestConsolidatorArchiveErrorHandling:
             {"role": "assistant", "content": "Done, fixed the race condition."},
         ]
         result = await _archive(consolidator, messages, runtime)
-        assert result is not None
-        assert "[RAW]" in result
+        assert result is None
         entries = store.read_unprocessed_history(since_cursor=0)
         assert len(entries) == 1
         assert "[RAW]" in entries[0]["content"]
@@ -453,8 +336,33 @@ class TestConsolidatorArchiveErrorHandling:
         consolidator.store.raw_archive.assert_not_called()
 
 
-class TestConsolidatorPromptEstimate:
-    async def test_estimate_uses_full_unarchived_tail(self, consolidator, runtime):
+class TestConsolidatorTokenBudget:
+    async def test_prompt_below_threshold_does_not_consolidate(
+        self, consolidator, runtime
+    ):
+        """No consolidation when tokens are within budget."""
+        session = MagicMock()
+        session.last_consolidated = 0
+        session.messages = [{"role": "user", "content": "hi"}]
+        session.key = "test:key"
+        consolidator.sessions._session_cache[session.key] = session
+        consolidator.estimate_session_prompt_tokens = MagicMock(return_value=(100, "tiktoken"))
+        consolidator.archive_session = AsyncMock(return_value=True)
+        await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+        consolidator.archive_session.assert_not_called()
+
+    async def test_token_estimation_failure_propagates(self, consolidator, runtime):
+        session = Session(key="test:estimate-failure")
+        session.add_message("user", "hello")
+        consolidator.sessions._session_cache[session.key] = session
+        consolidator.estimate_session_prompt_tokens = MagicMock(
+            side_effect=RuntimeError("counter failed")
+        )
+
+        with pytest.raises(RuntimeError, match="counter failed"):
+            await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+
+    async def test_estimate_uses_full_unconsolidated_tail(self, consolidator, runtime):
         """Consolidation pressure must account for the full unarchived tail."""
         session = Session(key="test:full-tail")
         for i in range(160):
@@ -477,7 +385,7 @@ class TestConsolidatorPromptEstimate:
         session = Session(key="test:archived-replay")
         for i in range(10):
             session.add_message("user", f"msg-{i}")
-        session.last_archived = len(session.messages)
+        session.last_consolidated = len(session.messages)
 
         captured: dict[str, list[dict]] = {}
 
@@ -492,6 +400,130 @@ class TestConsolidatorPromptEstimate:
         assert len(captured["history"]) == 8
         assert captured["history"][0]["content"] == "msg-2"
 
+    async def test_token_overflow_appends_prompt_to_replay_prefix(
+        self,
+        consolidator,
+        mock_provider,
+        runtime,
+    ):
+        consolidator._SAFETY_BUFFER = 0
+        session = Session(key="test:token-prefix")
+        session.provider_state = _provider_state()
+        session.messages = [
+            {
+                "role": "user" if i in {0, 50, 61} else "assistant",
+                "content": f"m{i}",
+            }
+            for i in range(70)
+        ]
+        consolidator.sessions._session_cache[session.key] = session
+        consolidator.estimate_session_prompt_tokens = MagicMock(
+            side_effect=[(1200, "tiktoken"), (400, "tiktoken")]
+        )
+        consolidator.pick_consolidation_boundary = MagicMock(return_value=(50, 800))
+        consolidator._build_messages = MagicMock(side_effect=_build_test_messages)
+        mock_provider.estimate_prompt_tokens.return_value = (100, "test-counter")
+        mock_provider.chat_with_retry.return_value = LLMResponse(
+            content="Token overflow summary.",
+            finish_reason="stop",
+        )
+
+        await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+
+        request = mock_provider.chat_with_retry.await_args.kwargs
+        assert [message["content"] for message in request["messages"][1:-1]] == [
+            f"m{i}" for i in range(50)
+        ]
+        assert "final 50 conversation messages" in request["messages"][-1]["content"]
+        assert request["tools"] == []
+        assert request["tool_choice"] == "none"
+        assert session.last_consolidated == 50
+        assert session.provider_state is None
+
+    async def test_raw_archive_fallback_advances_last_consolidated(
+        self, consolidator, runtime
+    ):
+        """When archive() falls back to raw-archive (LLM failed), the cursor
+        must still advance. Otherwise the same chunk gets raw-archived again
+        on every subsequent maybe_consolidate_by_tokens() call, spamming
+        duplicate [RAW] entries into history.jsonl."""
+        consolidator._SAFETY_BUFFER = 0
+        session = MagicMock()
+        session.last_consolidated = 0
+        session.key = "test:key"
+        session.messages = [
+            {"role": "user" if i in {0, 50} else "assistant", "content": f"m{i}"}
+            for i in range(70)
+        ]
+        session.metadata = {}
+        consolidator.sessions._session_cache[session.key] = session
+        consolidator.estimate_session_prompt_tokens = MagicMock(
+            side_effect=[(1200, "tiktoken"), (400, "tiktoken")]
+        )
+        # LLM consolidation fails after raw_archive fires.
+        consolidator.archive_session = AsyncMock(return_value=None)
+
+        await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+
+        consolidator.archive_session.assert_awaited_once()
+        # The chunk is considered "materialized" (as a raw-archive breadcrumb),
+        # so last_consolidated must have moved past it.
+        assert session.last_consolidated == 50
+
+    async def test_raw_archive_fallback_breaks_round_loop(
+        self, consolidator, runtime
+    ):
+        """A degraded LLM should not trigger more archive() calls within the
+        same maybe_consolidate_by_tokens invocation — bail after one fallback."""
+        consolidator._SAFETY_BUFFER = 0
+        session = MagicMock()
+        session.last_consolidated = 0
+        session.key = "test:key"
+        session.messages = [
+            {"role": "user" if i in {0, 20, 40, 60} else "assistant", "content": f"m{i}"}
+            for i in range(70)
+        ]
+        session.metadata = {}
+        consolidator.sessions._session_cache[session.key] = session
+        # Keep estimates high so the loop would otherwise run multiple rounds.
+        consolidator.estimate_session_prompt_tokens = MagicMock(
+            return_value=(1200, "tiktoken")
+        )
+        consolidator.archive_session = AsyncMock(return_value=None)
+
+        await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+
+        # Exactly one fallback per call — not _MAX_CONSOLIDATION_ROUNDS.
+        assert consolidator.archive_session.await_count == 1
+
+    async def test_boundary_respected_when_no_intermediate_user_turn(
+        self, consolidator, runtime
+    ):
+        """When boundary points past a long tool chain, the full chunk is archived."""
+        consolidator._SAFETY_BUFFER = 0
+        session = MagicMock()
+        session.last_consolidated = 0
+        session.key = "test:key"
+        session.messages = [
+            {
+                "role": "user" if i in {0, 61} else "assistant",
+                "content": f"m{i}",
+            }
+            for i in range(70)
+        ]
+        consolidator.sessions._session_cache[session.key] = session
+        consolidator.estimate_session_prompt_tokens = MagicMock(
+            side_effect=[(1200, "tiktoken"), (400, "tiktoken")]
+        )
+        consolidator.archive_session = AsyncMock(return_value=True)
+
+        await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+
+        consolidator.archive_session.assert_awaited_once()
+        # pick_consolidation_boundary finds the only boundary at idx=61
+        assert session.last_consolidated == 61
+
+
 class TestCompactIdleSession:
     """Idle compaction tests."""
 
@@ -543,8 +575,8 @@ class TestCompactIdleSession:
         reloaded = sessions.get_or_create("cli:test")
         assert len(reloaded.messages) == 40
         assert reloaded.messages[0]["content"] == "user msg 0"
-        assert reloaded.last_archived == 40
-        assert reloaded.provider_state == _provider_state()
+        assert reloaded.last_consolidated == 40
+        assert reloaded.provider_state is None
         visible = reloaded.get_history(max_messages=40)
         assert len(visible) == 8
         assert visible[0]["content"] == "user msg 16"
@@ -576,65 +608,30 @@ class TestCompactIdleSession:
         mock_provider.chat_with_retry.assert_awaited_once()
         assert len(store.read_unprocessed_history(since_cursor=0)) == 1
         reloaded = sessions.get_or_create("cli:short")
-        assert reloaded.last_archived == 2
+        assert reloaded.last_consolidated == 2
         assert [message["content"] for message in reloaded.get_history()] == ["hello", "hi"]
 
-    @pytest.mark.asyncio
-    async def test_idle_compaction_with_no_new_messages_is_noop(
-        self, real_consolidator, mock_provider, store, runtime
-    ):
-        sessions = real_consolidator.sessions
-        session = sessions.get_or_create("cli:archived-idle")
-        session.add_message("user", "already archived")
-        session.add_message("assistant", "old answer")
-        session.last_archived = 2
-        sessions.save(session)
-        sessions.invalidate("cli:archived-idle")
-
-        result = await real_consolidator.compact_idle_session(
-            "cli:archived-idle",
-            runtime=runtime,
-        )
-
-        assert result == ""
-        mock_provider.chat_with_retry.assert_not_awaited()
-        reloaded = sessions.get_or_create("cli:archived-idle")
-        assert reloaded.last_archived == 2
-        assert "_last_summary" not in reloaded.metadata
-        assert store.read_unprocessed_history(since_cursor=0) == []
-
     @pytest.mark.asyncio
     async def test_new_messages_advance_existing_archive_progress(
         self, real_consolidator, mock_provider, runtime
     ):
-        mock_provider.chat_with_retry.side_effect = [
-            MagicMock(content="First replacement checkpoint.", finish_reason="stop"),
-            MagicMock(content="Second replacement checkpoint.", finish_reason="stop"),
-        ]
+        mock_provider.chat_with_retry.return_value = MagicMock(
+            content="Summary.", finish_reason="stop"
+        )
         sessions = real_consolidator.sessions
         session = sessions.get_or_create("cli:incremental")
         session.add_message("user", "first user")
         session.add_message("assistant", "first assistant")
         sessions.save(session)
 
-        first = await real_consolidator.compact_idle_session(
-            "cli:incremental",
-            runtime=runtime,
-        )
+        await real_consolidator.compact_idle_session("cli:incremental", runtime=runtime)
         current = sessions.get_or_create("cli:incremental")
         current.add_message("user", "second user")
         current.add_message("assistant", "second assistant")
         sessions.save(current)
-        second = await real_consolidator.compact_idle_session(
-            "cli:incremental",
-            runtime=runtime,
-        )
+        await real_consolidator.compact_idle_session("cli:incremental", runtime=runtime)
 
-        assert first == "First replacement checkpoint."
-        assert second == "Second replacement checkpoint."
         assert mock_provider.chat_with_retry.await_count == 2
-        latest_build = real_consolidator.archiver._build_messages.call_args_list[-1].kwargs
-        assert latest_build["session_summary"]["text"] == "First replacement checkpoint."
         latest_messages = mock_provider.chat_with_retry.await_args_list[-1].kwargs["messages"]
         assert [message["content"] for message in latest_messages[1:5]] == [
             "first user",
@@ -642,91 +639,8 @@ class TestCompactIdleSession:
             "second user",
             "second assistant",
         ]
-        assert latest_messages[-1]["content"] == _ARCHIVE_PROMPT
-        sessions.invalidate("cli:incremental")
-        reloaded = sessions.get_or_create("cli:incremental")
-        assert reloaded.last_archived == 4
-        assert reloaded.metadata["_last_summary"]["text"] == second
-
-    @pytest.mark.asyncio
-    async def test_raw_fallback_preserves_previous_checkpoint_and_new_chunk(
-        self,
-        real_consolidator,
-        mock_provider,
-        store,
-        runtime,
-    ):
-        mock_provider.chat_with_retry.side_effect = [
-            LLMResponse(content="Earlier durable checkpoint.", finish_reason="stop"),
-            RuntimeError("LLM unavailable"),
-        ]
-        sessions = real_consolidator.sessions
-        session = sessions.get_or_create("cli:cumulative-fallback")
-        session.add_message("user", "first user")
-        session.add_message("assistant", "first answer")
-        sessions.save(session)
-
-        await real_consolidator.compact_idle_session(
-            "cli:cumulative-fallback",
-            runtime=runtime,
-        )
-        current = sessions.get_or_create("cli:cumulative-fallback")
-        current.add_message("user", "second user")
-        current.add_message("assistant", "newest working state")
-        sessions.save(current)
-
-        fallback = await real_consolidator.compact_idle_session(
-            "cli:cumulative-fallback",
-            runtime=runtime,
-        )
-
-        assert fallback is not None
-        assert "[Previous archived context]" in fallback
-        assert "Earlier durable checkpoint." in fallback
-        assert "[Newly archived raw context]" in fallback
-        assert "newest working state" in fallback
-        entries = store.read_unprocessed_history(0)
-        assert entries[0]["content"] == "Earlier durable checkpoint."
-        assert entries[1]["content"].startswith("[RAW] 2 messages")
-        sessions.invalidate("cli:cumulative-fallback")
-        reloaded = sessions.get_or_create("cli:cumulative-fallback")
-        assert reloaded.metadata["_last_summary"]["text"] == fallback
-
-    @pytest.mark.asyncio
-    async def test_nothing_keeps_previous_replacement_checkpoint(
-        self,
-        real_consolidator,
-        mock_provider,
-        runtime,
-    ):
-        mock_provider.chat_with_retry.side_effect = [
-            LLMResponse(content="Existing checkpoint.", finish_reason="stop"),
-            LLMResponse(content="(nothing)", finish_reason="stop"),
-        ]
-        sessions = real_consolidator.sessions
-        session = sessions.get_or_create("cli:nothing-after-summary")
-        session.add_message("user", "important first turn")
-        session.add_message("assistant", "important result")
-        sessions.save(session)
-        await real_consolidator.compact_idle_session(
-            "cli:nothing-after-summary",
-            runtime=runtime,
-        )
-
-        current = sessions.get_or_create("cli:nothing-after-summary")
-        current.add_message("user", "thanks")
-        current.add_message("assistant", "you're welcome")
-        sessions.save(current)
-        result = await real_consolidator.compact_idle_session(
-            "cli:nothing-after-summary",
-            runtime=runtime,
-        )
-
-        assert result == "(nothing)"
-        sessions.invalidate("cli:nothing-after-summary")
-        reloaded = sessions.get_or_create("cli:nothing-after-summary")
-        assert reloaded.last_archived == 4
-        assert reloaded.metadata["_last_summary"]["text"] == "Existing checkpoint."
+        assert "final 2 conversation messages" in latest_messages[-1]["content"]
+        assert sessions.get_or_create("cli:incremental").last_consolidated == 4
 
     @pytest.mark.asyncio
     async def test_concurrent_append_remains_unarchived(
@@ -750,13 +664,13 @@ class TestCompactIdleSession:
 
         reloaded = sessions.get_or_create("cli:concurrent")
         assert len(reloaded.messages) == 4
-        assert reloaded.last_archived == 2
+        assert reloaded.last_consolidated == 2
 
     @pytest.mark.asyncio
     async def test_summarizes_retained_suffix_not_just_dropped_prefix(
         self, real_consolidator, mock_provider, runtime
     ):
-        """idleCompact must summarize over the full unarchived tail, including
+        """idleCompact must summarize over the full unconsolidated tail, including
         the recent suffix it retains. Otherwise a late user correction / final
         result that lands in the kept suffix is excluded from the persisted
         summary, leaving a stale wrong conclusion in history. Regression for #4264."""
@@ -791,7 +705,6 @@ class TestCompactIdleSession:
         mock_provider.chat_with_retry.side_effect = RuntimeError("LLM unavailable")
         sessions = real_consolidator.sessions
         session = sessions.get_or_create("cli:rawdrop")
-        session.provider_state = _provider_state()
         for i in range(18):
             session.add_message("user", f"user msg {i}")
             session.add_message("assistant", f"assistant msg {i}")
@@ -810,7 +723,6 @@ class TestCompactIdleSession:
         reloaded = sessions.get_or_create("cli:rawdrop")
         assert len(reloaded.messages) == 38
         assert reloaded.messages[-1]["content"] == "RETAINED_SUFFIX_marker"
-        assert reloaded.provider_state == _provider_state()
 
     @pytest.mark.asyncio
     async def test_idle_compact_writes_session_key_to_history(
@@ -876,16 +788,11 @@ class TestCompactIdleSession:
         result = await real_consolidator.compact_idle_session(
             "cli:nothing", runtime=runtime, max_suffix=4
         )
-        second = await real_consolidator.compact_idle_session(
-            "cli:nothing", runtime=runtime, max_suffix=4
-        )
         assert result == "(nothing)"
-        assert second == ""
 
         reloaded = sessions.get_or_create("cli:nothing")
         assert "_last_summary" not in reloaded.metadata
         assert real_consolidator.store.read_unprocessed_history(0) == []
-        mock_provider.chat_with_retry.assert_awaited_once()
 
     @pytest.mark.asyncio
     async def test_llm_failure_preserves_history_but_advances_replay_boundary(
@@ -902,8 +809,7 @@ class TestCompactIdleSession:
         result = await real_consolidator.compact_idle_session(
             "cli:fail", runtime=runtime, max_suffix=4
         )
-        assert result is not None
-        assert "[RAW]" in result
+        assert result is None
 
         # raw_archive should have been called (history.jsonl gets an entry)
         entries = store.read_unprocessed_history(since_cursor=0)
@@ -912,8 +818,7 @@ class TestCompactIdleSession:
         reloaded = sessions.get_or_create("cli:fail")
         assert len(reloaded.messages) == 20
         assert reloaded.messages[0]["content"] == "u0"
-        assert reloaded.last_archived == 20
-        assert reloaded.metadata["_last_summary"]["text"] == result
+        assert reloaded.last_consolidated == 20
         assert [m["content"] for m in reloaded.get_history(max_messages=20)] == [
             "u6",
             "a6",
@@ -926,10 +831,10 @@ class TestCompactIdleSession:
         ]
 
     @pytest.mark.asyncio
-    async def test_respects_last_archived(
+    async def test_respects_last_consolidated(
         self, real_consolidator, mock_provider, runtime
     ):
-        """30 turns with last_archived=50 → only the unarchived tail is considered."""
+        """30 turns with last_consolidated=50 → only unconsolidated tail considered."""
         mock_provider.chat_with_retry.return_value = MagicMock(
             content="Tail summary.", finish_reason="stop"
         )
@@ -938,7 +843,7 @@ class TestCompactIdleSession:
         for i in range(30):
             session.add_message("user", f"u{i}")
             session.add_message("assistant", f"a{i}")
-        session.last_archived = 50  # Only 10 messages remain unarchived
+        session.last_consolidated = 50  # Only 10 messages unconsolidated
         sessions.save(session)
 
         result = await real_consolidator.compact_idle_session(
@@ -947,17 +852,18 @@ class TestCompactIdleSession:
         assert result == "Tail summary."
         reloaded = sessions.get_or_create("cli:offset")
         assert len(reloaded.messages) == 60
-        assert reloaded.last_archived == 60
+        assert reloaded.last_consolidated == 60
 
-        # Verify only the unarchived tail was processed:
-        # All 10 unarchived messages (50-59) are archived exactly once.
+        # Verify only the unconsolidated tail was processed:
+        # All 10 unconsolidated messages (50-59) are archived exactly once.
         archived_call = mock_provider.chat_with_retry.call_args
         sent_messages = archived_call.kwargs["messages"]
         sent_content = [message.get("content") for message in sent_messages]
-        # The replacement overview covers all model-visible conversation context.
+        # The ordinary replay prefix contributes recent context, while the
+        # temporary instruction limits the new overview to the unarchived tail.
         assert "u0" not in sent_content
         assert "u26" in sent_content
-        assert sent_messages[-1]["content"] == _ARCHIVE_PROMPT
+        assert "final 10 conversation messages" in sent_messages[-1]["content"]
 
     @pytest.mark.asyncio
     async def test_full_archive_keeps_extended_legal_replay_suffix(
@@ -984,7 +890,7 @@ class TestCompactIdleSession:
 
         reloaded = sessions.get_or_create("cli:noncontiguous")
         assert len(reloaded.messages) == 25
-        assert reloaded.last_archived == 25
+        assert reloaded.last_consolidated == 25
         assert [m["content"] for m in reloaded.get_history(max_messages=25)] == [
             "user-14",
             "assistant-00",
@@ -999,7 +905,7 @@ class TestCompactIdleSession:
             "assistant-09",
         ]
 
-        # #4264: idle compaction now summarizes the full unarchived tail, so
+        # #4264: idle compaction now summarizes the full unconsolidated tail, so
         # the dropped head (user-00) and retained suffix (user-14 through
         # assistant-09) are all summarized.
         archived_call = mock_provider.chat_with_retry.call_args
@@ -1017,7 +923,7 @@ class TestCompactIdleSession:
         runtime,
     ):
         tools = [{"type": "function", "function": {"name": "lookup"}}]
-        real_consolidator.archiver._get_tool_definitions.return_value = tools
+        real_consolidator._get_tool_definitions.return_value = tools
         mock_provider.chat_with_retry.return_value = LLMResponse(
             content="Overview from the temporary turn.",
             finish_reason="stop",
@@ -1046,9 +952,9 @@ class TestCompactIdleSession:
             "user",
         ]
         assert sent_messages[2]["tool_calls"][0]["id"] == "call-1"
-        assert sent_messages[-1]["content"] == _ARCHIVE_PROMPT
+        assert "final 4 conversation messages" in sent_messages[-1]["content"]
         assert call["tools"] == tools
-        assert "tool_choice" not in call
+        assert call["tool_choice"] == "none"
 
         reloaded = sessions.get_or_create("cli:tool-history")
         assert len(reloaded.messages) == 4
@@ -1086,13 +992,12 @@ class TestCompactIdleSession:
             runtime=runtime,
         )
 
-        assert result is not None
-        assert "[RAW]" in result
+        assert result is None
         entries = store.read_unprocessed_history(since_cursor=0)
         assert len(entries) == 1
         assert entries[0]["content"].startswith("[RAW] ")
         assert "important answer" in entries[0]["content"]
-        assert sessions.get_or_create("cli:unexpected-tool").last_archived == 2
+        assert sessions.get_or_create("cli:unexpected-tool").last_consolidated == 2
 
     @pytest.mark.asyncio
     async def test_empty_response_uses_raw_fallback(
@@ -1117,13 +1022,12 @@ class TestCompactIdleSession:
             runtime=runtime,
         )
 
-        assert result is not None
-        assert "[RAW]" in result
+        assert result is None
         entries = store.read_unprocessed_history(since_cursor=0)
         assert len(entries) == 1
         assert entries[0]["content"].startswith("[RAW] ")
         assert "important answer" in entries[0]["content"]
-        assert sessions.get_or_create("cli:empty-summary").last_archived == 2
+        assert sessions.get_or_create("cli:empty-summary").last_consolidated == 2
 
     @pytest.mark.asyncio
     async def test_oversized_prefix_raw_archives_without_flattened_llm_retry(
@@ -1144,16 +1048,15 @@ class TestCompactIdleSession:
             runtime=runtime,
         )
 
-        assert result is not None
-        assert "[RAW]" in result
+        assert result is None
         mock_provider.chat_with_retry.assert_not_awaited()
         entries = store.read_unprocessed_history(since_cursor=0)
         assert len(entries) == 1
         assert entries[0]["content"].startswith("[RAW] ")
-        assert sessions.get_or_create("sdk:oversized").last_archived == 1
+        assert sessions.get_or_create("sdk:oversized").last_consolidated == 1
 
     @pytest.mark.asyncio
-    async def test_archive_context_contains_only_model_visible_messages(
+    async def test_incremental_scope_counts_only_model_visible_messages(
         self,
         real_consolidator,
         mock_provider,
@@ -1167,7 +1070,7 @@ class TestCompactIdleSession:
         session = sessions.get_or_create("cli:commands")
         session.add_message("user", "already archived user")
         session.add_message("assistant", "already archived answer")
-        session.last_archived = 2
+        session.last_consolidated = 2
         session.add_message("user", "/status", _command=True)
         session.add_message("assistant", "status output", _command=True)
         session.add_message("user", "new user")
@@ -1186,7 +1089,7 @@ class TestCompactIdleSession:
             "new user",
             "new answer",
         ]
-        assert sent[-1]["content"] == _ARCHIVE_PROMPT
+        assert "final 2 conversation messages" in sent[-1]["content"]
 
     @pytest.mark.asyncio
     async def test_reuses_real_prefix_for_unified_session_workspace(
@@ -1219,6 +1122,8 @@ class TestCompactIdleSession:
             current_message="next project question",
             channel="websocket",
             workspace=project,
+            session_key=session.key,
+            unified_session=True,
         )
 
         await loop.consolidator.compact_idle_session(
@@ -1228,7 +1133,7 @@ class TestCompactIdleSession:
 
         sent_messages = runtime.provider.chat_with_retry.call_args.kwargs["messages"]
         assert sent_messages[:-1] == ordinary_messages[:-1]
-        assert sent_messages[-1]["content"] == _ARCHIVE_PROMPT
+        assert "final 2 conversation messages" in sent_messages[-1]["content"]
         system = sent_messages[0]["content"]
         assert "PROJECT_WORKSPACE_MARKER" in system
         assert "GLOBAL_WORKSPACE_MARKER" not in system
@@ -1273,6 +1178,110 @@ class TestCompactIdleSession:
         assert not lock.locked()
 
 
+class TestConsolidatorSessionRefresh:
+    """Background consolidation must detect stale session references."""
+
+    @pytest.mark.asyncio
+    async def test_reloads_before_empty_session_guard(self, tmp_path):
+        """A stale empty reference must not skip a non-empty cached session."""
+        from nanobot.agent.memory import Consolidator, MemoryStore
+        from nanobot.session.manager import Session, SessionManager
+
+        store = MemoryStore(tmp_path)
+        provider = MagicMock()
+        provider.chat_with_retry = AsyncMock(
+            return_value=MagicMock(content="summary", finish_reason="stop")
+        )
+        provider.generation = GenerationSettings(max_tokens=4096)
+        provider.estimate_prompt_tokens = MagicMock(return_value=(10, "test"))
+        runtime = LLMRuntime.capture(
+            provider,
+            "test-model",
+            context_window_tokens=128_000,
+        )
+        sessions = SessionManager(tmp_path)
+        consolidator = Consolidator(
+            store=store,
+            sessions=sessions,
+            build_messages=MagicMock(return_value=[]),
+            get_tool_definitions=MagicMock(return_value=[]),
+        )
+
+        fresh = sessions.get_or_create("cli:test")
+        fresh.add_message("user", "fresh message")
+        sessions.save(fresh)
+        stale_empty = Session(key="cli:test")
+
+        seen: dict[str, Session] = {}
+
+        def estimate(session: Session, *, runtime):
+            seen["session"] = session
+            return 10, "test"
+
+        consolidator.estimate_session_prompt_tokens = MagicMock(side_effect=estimate)
+
+        await consolidator.maybe_consolidate_by_tokens(
+            stale_empty,
+            runtime=runtime,
+        )
+
+        assert seen["session"] is fresh
+
+    @pytest.mark.asyncio
+    async def test_reloads_stale_session_after_compact(self, tmp_path):
+        """After compact_idle_session replaces the session, a concurrent
+        maybe_consolidate_by_tokens with the old reference should use the
+        fresh session from cache instead of overwriting."""
+        from nanobot.agent.memory import Consolidator, MemoryStore
+        from nanobot.session.manager import SessionManager
+
+        store = MemoryStore(tmp_path)
+        provider = MagicMock()
+        provider.chat_with_retry = AsyncMock(
+            return_value=MagicMock(content="summary", finish_reason="stop")
+        )
+        provider.generation = GenerationSettings(max_tokens=4096)
+        provider.estimate_prompt_tokens = MagicMock(return_value=(10, "test"))
+        runtime = LLMRuntime.capture(
+            provider,
+            "test-model",
+            context_window_tokens=128_000,
+        )
+        sessions = SessionManager(tmp_path)
+        consolidator = Consolidator(
+            store=store,
+            sessions=sessions,
+            build_messages=MagicMock(return_value=[]),
+            get_tool_definitions=MagicMock(return_value=[]),
+        )
+
+        # Populate session with many messages
+        session = sessions.get_or_create("cli:test")
+        for i in range(20):
+            session.add_message("user", f"u{i}")
+            session.add_message("assistant", f"a{i}")
+        sessions.save(session)
+
+        # Simulate: background consolidation captures old reference
+        old_ref = session
+
+        await consolidator.compact_idle_session(
+            "cli:test",
+            runtime=runtime,
+            max_suffix=8,
+        )
+
+        await consolidator.maybe_consolidate_by_tokens(
+            old_ref,
+            runtime=runtime,
+        )
+
+        session_after = sessions.get_or_create("cli:test")
+        assert len(session_after.messages) == 40
+        assert session_after.last_consolidated == 40
+        assert len(session_after.get_history(max_messages=40)) == 8
+
+
 class TestRawArchiveTruncation:
     """raw_archive() must cap entry size to avoid bloating history.jsonl."""
 
@@ -1294,21 +1303,6 @@ class TestRawArchiveTruncation:
         assert len(entries) == 1
         assert "hello" in entries[0]["content"]
 
-    def test_raw_archive_returns_the_sanitized_persisted_checkpoint(self, store):
-        messages = [
-            {
-                "role": "user",
-                "content": "<think>PRIVATE_REASONING</think>visible result",
-            }
-        ]
-
-        checkpoint = store.raw_archive(messages, session_key="cli:test")
-
-        persisted = store.read_unprocessed_history(since_cursor=0)[0]["content"]
-        assert checkpoint == persisted
-        assert "PRIVATE_REASONING" not in checkpoint
-        assert "visible result" in checkpoint
-
     def test_raw_archive_excludes_model_only_runtime_context(self, store):
         content, marker = append_runtime_context(
             "ship the feature",
@@ -1340,40 +1334,21 @@ class TestRawArchiveTruncation:
 
 
 class TestArchivePersistence:
-    async def test_archive_returns_the_sanitized_persisted_summary(
-        self, consolidator, mock_provider, store, runtime
-    ):
-        mock_provider.chat_with_retry.return_value = MagicMock(
-            content="<think>PRIVATE_REASONING</think>safe summary",
-            finish_reason="stop",
-            has_tool_calls=False,
-        )
-
-        summary = await _archive(
-            consolidator,
-            [{"role": "user", "content": "hi"}],
-            runtime,
-        )
-
-        persisted = store.read_unprocessed_history(since_cursor=0)[0]["content"]
-        assert summary == persisted == "safe summary"
-
-    async def test_oversized_summary_uses_history_emergency_cap(
+    async def test_oversized_summary_is_capped_before_append(
         self, consolidator, mock_provider, store, runtime
     ):
         """A pathologically large LLM summary must not land full-length in
         history.jsonl — that would re-open the #3412 bloat vector from the
         *success* path instead of the fallback path."""
         mock_provider.chat_with_retry.return_value = MagicMock(
-            content="S" * (_HISTORY_ENTRY_HARD_CAP * 2),
+            content="S" * (_ARCHIVE_SUMMARY_MAX_CHARS * 10),
             finish_reason="stop",
         )
-        summary = await _archive(
+        await _archive(
             consolidator,
             [{"role": "user", "content": "hi"}],
             runtime,
         )
 
         entry = store.read_unprocessed_history(since_cursor=0)[0]
-        assert len(entry["content"]) <= _HISTORY_ENTRY_HARD_CAP + 50
-        assert summary == entry["content"]
+        assert len(entry["content"]) <= _ARCHIVE_SUMMARY_MAX_CHARS + 50

tests/agent/test_context_builder.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 import pytest
 
-from nanobot.agent.context import ContextBuilder, TranscriptInput
+from nanobot.agent.context import ContextBuilder
 from nanobot.runtime_context import RuntimeContextBlock
 
 # ---------------------------------------------------------------------------
@@ -133,7 +133,10 @@ class TestLoadBootstrapFiles:
         (project / "SOUL.md").write_text("project soul collision", encoding="utf-8")
         (project / "USER.md").write_text("project user collision", encoding="utf-8")
 
-        result = ContextBuilder(agent_home).build_system_prompt(workspace=project)
+        result = ContextBuilder(agent_home).build_system_prompt(
+            workspace=project,
+            include_memory_recent_history=False,
+        )
 
         assert "selected project rules" in result
         assert "global project rules" not in result
@@ -149,7 +152,10 @@ class TestLoadBootstrapFiles:
         project.mkdir()
         (agent_home / "AGENTS.md").write_text("default workspace rules", encoding="utf-8")
 
-        result = ContextBuilder(agent_home).build_system_prompt(workspace=project)
+        result = ContextBuilder(agent_home).build_system_prompt(
+            workspace=project,
+            include_memory_recent_history=False,
+        )
 
         assert "default workspace rules" not in result
 
@@ -397,15 +403,6 @@ class TestBuildMessages:
         assert "user-only runtime context" not in messages[-1]["content"]
         assert "_meta" not in messages[-1]
 
-    def test_compatibility_builder_merges_system_role_without_history(self, tmp_path):
-        builder = _builder(tmp_path)
-
-        messages = builder.build_messages([], "system event", current_role="system")
-
-        assert len(messages) == 1
-        assert messages[0]["role"] == "system"
-        assert str(messages[0]["content"]).endswith("system event")
-
     def test_explicit_skill_reference_loads_full_instructions_for_this_turn(self, tmp_path):
         skill_dir = tmp_path / "skills" / "review"
         skill_dir.mkdir(parents=True)
@@ -475,20 +472,6 @@ class TestBuildMessages:
         assert "previous user message" in str(messages[1]["content"])
         assert "new message" in str(messages[1]["content"])
 
-    def test_structured_transcript_preserves_fresh_turn_boundary(self, tmp_path):
-        builder = _builder(tmp_path)
-        transcript = TranscriptInput(
-            history=[{"role": "user", "content": "previous user message"}],
-            current_message="new message",
-        )
-
-        messages = builder.build_transcript(transcript)
-
-        assert [message["role"] for message in messages] == ["system", "user", "user"]
-        assert messages[-2]["content"] == "previous user message"
-        assert messages[-1]["content"] == "new message"
-        assert transcript.message_count == 3
-
     def test_current_message_can_be_built_without_history_merge(self, tmp_path):
         builder = _builder(tmp_path)
         current = builder.build_current_message(

tests/agent/test_context_prompt_cache.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import datetime as datetime_module
+import re
 from datetime import datetime as real_datetime
 from importlib.resources import files as pkg_files
 from pathlib import Path
@@ -103,6 +104,173 @@ def test_provider_context_appended_after_user_content(tmp_path) -> None:
     assert user_pos < context_pos, "user content must precede provider context"
 
 
+def test_unprocessed_history_injected_into_system_prompt(tmp_path) -> None:
+    """Entries in history.jsonl not yet consumed by Dream appear with timestamps."""
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    builder.memory.append_history("User asked about weather in Tokyo")
+    builder.memory.append_history("Agent fetched forecast via web_search")
+
+    prompt = builder.build_system_prompt()
+    assert "# Recent History" in prompt
+    assert "User asked about weather in Tokyo" in prompt
+    assert "Agent fetched forecast via web_search" in prompt
+    assert re.search(r"\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}\]", prompt)
+
+
+def test_recent_history_injection_is_session_scoped(tmp_path) -> None:
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    builder.memory.append_history("legacy entry without session")
+    builder.memory.append_history("telegram history", session_key="telegram:chat-1")
+    builder.memory.append_history("slack history", session_key="slack:chat-2")
+
+    prompt = builder.build_system_prompt(session_key="telegram:chat-1")
+
+    assert "# Recent History" in prompt
+    assert "telegram history" in prompt
+    assert "slack history" not in prompt
+    assert "legacy entry without session" not in prompt
+
+
+def test_session_summary_replaces_interleaved_recent_history_entry(tmp_path) -> None:
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+    session_key = "unified:default"
+    overview = "CURRENT_SESSION_OVERVIEW_MARKER"
+
+    builder.memory.append_history("another session event", session_key=session_key)
+    builder.memory.append_history(overview, session_key=session_key)
+    latest_cursor = builder.memory.append_history(
+        "later telegram event",
+        session_key="telegram:chat-1",
+    )
+    summary = {"text": overview, "last_active": "2026-08-19T10:00:00"}
+
+    prompt = builder.build_system_prompt(
+        session_key=session_key,
+        session_summary=summary,
+        unified_session=True,
+    )
+
+    assert "# Recent History" in prompt
+    assert "another session event" in prompt
+    assert "later telegram event" in prompt
+    assert "[Archived Context Summary]" in prompt
+    assert prompt.count(overview) == 1
+
+    builder.memory.set_last_dream_cursor(latest_cursor)
+    processed_prompt = builder.build_system_prompt(
+        session_key=session_key,
+        session_summary=summary,
+        unified_session=True,
+    )
+    assert "# Recent History" not in processed_prompt
+    assert processed_prompt.count(overview) == 1
+
+
+def test_recent_history_injection_unified_excludes_cron_internals(tmp_path) -> None:
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    builder.memory.append_history("unified user history", session_key="unified:default")
+    builder.memory.append_history("channel user history", session_key="telegram:chat-1")
+    builder.memory.append_history("cron internal history", session_key="cron:job-1")
+
+    prompt = builder.build_system_prompt(
+        session_key="unified:default",
+        unified_session=True,
+    )
+
+    assert "unified user history" in prompt
+    assert "channel user history" in prompt
+    assert "cron internal history" not in prompt
+
+
+def test_cron_recent_history_can_see_own_history_and_unified_context(tmp_path) -> None:
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    builder.memory.append_history("unified user history", session_key="unified:default")
+    builder.memory.append_history("own cron history", session_key="cron:job-1")
+    builder.memory.append_history("other cron history", session_key="cron:job-2")
+
+    prompt = builder.build_system_prompt(
+        session_key="cron:job-1",
+        unified_session=True,
+    )
+
+    assert "unified user history" in prompt
+    assert "own cron history" in prompt
+    assert "other cron history" not in prompt
+
+
+def test_recent_history_capped_at_max(tmp_path) -> None:
+    """Only the most recent _MAX_RECENT_HISTORY entries are injected."""
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    for i in range(builder._MAX_RECENT_HISTORY + 20):
+        builder.memory.append_history(f"entry-{i}")
+
+    prompt = builder.build_system_prompt()
+    assert "entry-0" not in prompt
+    assert "entry-19" not in prompt
+    assert f"entry-{builder._MAX_RECENT_HISTORY + 19}" in prompt
+
+
+def test_recent_history_truncated_at_max_tokens(tmp_path) -> None:
+    """Recent History section must be truncated to _MAX_HISTORY_TOKENS."""
+    import tiktoken
+
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    big_entry = "word " * (builder._MAX_HISTORY_TOKENS + 5_000)
+    builder.memory.append_history(big_entry)
+
+    prompt = builder.build_system_prompt()
+    history_section = prompt.split("# Recent History\n\n", 1)
+    assert len(history_section) == 2
+
+    enc = tiktoken.get_encoding("cl100k_base")
+    assert len(enc.encode(history_section[1])) <= builder._MAX_HISTORY_TOKENS
+
+
+def test_no_recent_history_when_dream_has_processed_all(tmp_path) -> None:
+    """If Dream has consumed everything, no Recent History section should appear."""
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    cursor = builder.memory.append_history("already processed entry")
+    builder.memory.set_last_dream_cursor(cursor)
+
+    prompt = builder.build_system_prompt()
+    assert "# Recent History" not in prompt
+
+
+def test_partial_dream_processing_shows_only_remainder(tmp_path) -> None:
+    """When Dream has processed some entries, only the unprocessed ones appear."""
+    workspace = _make_workspace(tmp_path)
+    builder = ContextBuilder(workspace)
+
+    builder.memory.append_history("old conversation about Python")
+    c2 = builder.memory.append_history("old conversation about Rust")
+    builder.memory.append_history("recent question about Docker")
+    builder.memory.append_history("recent question about K8s")
+
+    builder.memory.set_last_dream_cursor(c2)
+
+    prompt = builder.build_system_prompt()
+    assert "# Recent History" in prompt
+    assert "old conversation about Python" not in prompt
+    assert "old conversation about Rust" not in prompt
+    assert "recent question about Docker" in prompt
+    assert "recent question about K8s" in prompt
+
+
 def test_execution_rules_in_system_prompt(tmp_path) -> None:
     """Execution rules should appear in the system prompt via the default templates."""
     from nanobot.utils.helpers import sync_workspace_templates

tests/agent/test_dream.py

@@ -62,14 +62,28 @@ class TestBuildDreamPrompt:
         prompt, _ = result
         assert "skill-creator" in prompt
 
-    def test_prompt_does_not_duplicate_current_memory_file_contents(self, store):
+    def test_prompt_embeds_current_memory_file_contents(self, store):
+        """Dream must see the real current file contents (Tier 4) so it edits the
+        files, not a stale mental model."""
         store.append_history("hello")
         result = store.build_dream_prompt()
         assert result is not None
         prompt, _ = result
-        assert "## Current Memory Files" not in prompt
-        assert "Project X active" not in prompt
-        assert "Helpful" not in prompt
+        assert "## Current Memory Files" in prompt
+        assert "### SOUL.md" in prompt
+        assert "### USER.md" in prompt
+        assert "### memory/MEMORY.md" in prompt
+        # Real current contents are embedded verbatim.
+        assert "Project X active" in prompt
+        assert "Helpful" in prompt
+
+    def test_prompt_renders_missing_files_as_empty(self, tmp_path):
+        store = MemoryStore(tmp_path)  # no durable files written
+        store.append_history("hello")
+        result = store.build_dream_prompt()
+        assert result is not None
+        prompt, _ = result
+        assert "(empty)" in prompt
 
     def test_workspace_dream_prompt_overrides_default(self, store):
         store.dream_prompt_file.parent.mkdir(parents=True)
@@ -404,14 +418,15 @@ class TestEphemeralDirect:
         with (
             patch("nanobot.agent.loop.SessionManager"),
             patch("nanobot.agent.loop.SubagentManager") as mock_sub,
-            patch("nanobot.agent.loop.Consolidator"),
+            patch("nanobot.agent.loop.Consolidator") as mock_consolidator_cls,
         ):
             mock_sub.return_value.cancel_by_session = AsyncMock(return_value=0)
+            mock_consolidator_cls.return_value.maybe_consolidate_by_tokens = AsyncMock()
             loop = AgentLoop(
                 bus=bus,
                 provider=provider,
                 workspace=tmp_path,
-                context_window_tokens=32_000,
+                context_window_tokens=8000,
             )
 
         return loop, store
@@ -492,6 +507,20 @@ class TestEphemeralDirect:
 
         assert captured.get("ephemeral") is False
 
+    async def test_ephemeral_skips_consolidator(self, tmp_path, _make_loop):
+        """When ephemeral=True, consolidator.maybe_consolidate_by_tokens is not called."""
+        from unittest.mock import patch
+
+        loop, store = _make_loop
+
+        with patch.object(
+            loop.consolidator, "maybe_consolidate_by_tokens",
+        ) as mock_consolidate:
+            await loop.process_direct(
+                "test", session_key="dream:consolidate-test", ephemeral=True,
+            )
+            mock_consolidate.assert_not_called()
+
     async def test_ephemeral_response_reports_stop_reason(self, tmp_path, _make_loop):
         loop, store = _make_loop
         loop.provider.chat_with_retry.return_value = LLMResponse(
@@ -577,7 +606,7 @@ class TestEphemeralDirect:
             bus=MessageBus(),
             provider=provider,
             workspace=tmp_path,
-            context_window_tokens=32_000,
+            context_window_tokens=8000,
         )
 
         await loop.process_direct(
@@ -596,63 +625,6 @@ class TestEphemeralDirect:
         assert "entry-21" not in request_text
         assert "entry-60" not in request_text
 
-    async def test_dream_turn_injects_memory_files_once_and_persists_session(self, tmp_path):
-        """Dream gets durable files from system context without losing its session record."""
-        from unittest.mock import MagicMock
-
-        from nanobot.agent.loop import AgentLoop
-        from nanobot.bus.queue import MessageBus
-
-        markers = {
-            "SOUL.md": "DREAM_SOUL_MARKER",
-            "USER.md": "DREAM_USER_MARKER",
-            "memory/MEMORY.md": "DREAM_MEMORY_MARKER",
-        }
-        store = MemoryStore(tmp_path)
-        store.write_soul(markers["SOUL.md"])
-        store.write_user(markers["USER.md"])
-        store.write_memory(markers["memory/MEMORY.md"])
-        store.append_history("history-marker")
-        (tmp_path / "AGENTS.md").write_text("DREAM_AGENTS_MARKER", encoding="utf-8")
-
-        result = store.build_dream_prompt()
-        assert result is not None
-        prompt, _ = result
-
-        captured: dict[str, list[dict]] = {}
-        provider = MagicMock()
-        provider.get_default_model.return_value = "test-model"
-        provider.supports_tools = True
-        provider.generation = MagicMock(max_tokens=4096)
-
-        async def chat_with_retry(**kwargs):
-            captured["messages"] = kwargs["messages"]
-            return LLMResponse(content="done", finish_reason="stop")
-
-        provider.chat_with_retry = chat_with_retry
-        loop = AgentLoop(
-            bus=MessageBus(),
-            provider=provider,
-            workspace=tmp_path,
-            context_window_tokens=32_000,
-        )
-        session_key = "dream:single-memory-copy"
-
-        await loop.process_direct(
-            prompt,
-            session_key=session_key,
-            ephemeral=True,
-            tools=store.build_dream_tools(),
-        )
-
-        messages = captured["messages"]
-        system_prompt = str(messages[0]["content"])
-        request_text = "\n".join(str(message.get("content", "")) for message in messages)
-        for marker in [*markers.values(), "DREAM_AGENTS_MARKER"]:
-            assert marker in system_prompt
-            assert request_text.count(marker) == 1
-        assert loop.sessions._get_session_path(session_key).exists()
-
 
 class TestEphemeralHooks:
     """When ephemeral=True, extra hooks must not fire."""
@@ -686,14 +658,15 @@ class TestEphemeralHooks:
         with (
             patch("nanobot.agent.loop.SessionManager"),
             patch("nanobot.agent.loop.SubagentManager") as mock_sub,
-            patch("nanobot.agent.loop.Consolidator"),
+            patch("nanobot.agent.loop.Consolidator") as mock_consolidator_cls,
         ):
             mock_sub.return_value.cancel_by_session = AsyncMock(return_value=0)
+            mock_consolidator_cls.return_value.maybe_consolidate_by_tokens = AsyncMock()
             loop = AgentLoop(
                 bus=bus,
                 provider=provider,
                 workspace=tmp_path,
-                context_window_tokens=32_000,
+                context_window_tokens=8000,
                 hooks=[spy],
             )
 

tests/agent/test_history_replay.py

@@ -12,7 +12,6 @@ from nanobot.bus.events import InboundMessage
 from nanobot.bus.queue import MessageBus
 from nanobot.providers.base import LLMResponse
 from nanobot.session.manager import Session
-from nanobot.session.summary import SUMMARY_CONTINUATION_TEXT
 
 
 def _make_loop(tmp_path: Path, context_window_tokens: int = 200_000) -> AgentLoop:
@@ -67,12 +66,13 @@ def test_explicit_message_limit_still_starts_at_user_turn() -> None:
 
 
 @pytest.mark.asyncio
-async def test_process_message_hands_complete_replay_to_runner(tmp_path: Path) -> None:
+async def test_process_message_replays_with_token_budget_only(tmp_path: Path) -> None:
     loop = _make_loop(tmp_path, context_window_tokens=32_768)
     loop.provider.chat_with_retry = AsyncMock(
         return_value=LLMResponse(content="ok", tool_calls=[], usage=None)
     )
     loop.tools.get_definitions = MagicMock(return_value=[])
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     session = loop.sessions.get_or_create("cli:test")
     with patch.object(session, "get_history", wraps=session.get_history) as get_history:
@@ -81,16 +81,20 @@ async def test_process_message_hands_complete_replay_to_runner(tmp_path: Path) -
         )
 
     assert result is not None
-    assert get_history.call_args.kwargs == {"extend_to_user": False}
+    assert get_history.call_args.kwargs == {
+        "max_tokens": loop._replay_token_budget(loop.llm_runtime()),
+        "extend_to_user": False,
+    }
 
 
 @pytest.mark.asyncio
-async def test_runner_checkpoint_keeps_current_user_as_replay_boundary(tmp_path: Path) -> None:
+async def test_token_budget_keeps_current_user_as_replay_boundary(tmp_path: Path) -> None:
     loop = _make_loop(tmp_path, context_window_tokens=8_000)
     loop.provider.chat_with_retry = AsyncMock(
         return_value=LLMResponse(content="ok", tool_calls=[], usage=None)
     )
     loop.tools.get_definitions = MagicMock(return_value=[])
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     session = loop.sessions.get_or_create("cli:test")
     session.add_message("user", "old")
@@ -113,6 +117,4 @@ async def test_runner_checkpoint_keeps_current_user_as_replay_boundary(tmp_path:
     sent_messages = loop.provider.chat_with_retry.await_args.kwargs["messages"]
     sent_text = "\n".join(str(message.get("content")) for message in sent_messages)
     assert "new question" in sent_text
-    assert [message["role"] for message in sent_messages] == ["system", "user", "user"]
-    assert sent_messages[1]["content"] == SUMMARY_CONTINUATION_TEXT
-    assert any(message.get("content") == "long older turn" for message in session.messages)
+    assert "long older turn" not in sent_text

tests/agent/test_hook_composite.py

@@ -6,7 +6,6 @@ from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
-from nanobot.agent.context import TranscriptInput
 from nanobot.agent.hook import (
     AgentHook,
     AgentHookContext,
@@ -460,7 +459,7 @@ async def test_agent_loop_extra_hook_receives_calls(tmp_path):
     loop.tools.get_definitions = MagicMock(return_value=[])
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "hi"}], current_message=None),
+        [{"role": "user", "content": "hi"}],
         runtime=loop.llm_runtime(),
     )
 
@@ -505,7 +504,7 @@ async def test_agent_loop_turn_hook_factories_receive_context(tmp_path):
 
     runtime = loop.llm_runtime()
     await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "hi"}], current_message=None),
+        [{"role": "user", "content": "hi"}],
         runtime=runtime,
         on_progress=on_progress,
         request_context=RequestContext(
@@ -552,7 +551,7 @@ async def test_agent_loop_extra_hook_error_isolation(tmp_path):
     loop.tools.get_definitions = MagicMock(return_value=[])
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "hi"}], current_message=None),
+        [{"role": "user", "content": "hi"}],
         runtime=loop.llm_runtime(),
     )
 
@@ -578,9 +577,7 @@ async def test_agent_loop_extra_hooks_do_not_swallow_loop_hook_errors(tmp_path):
 
     with pytest.raises(RuntimeError, match="progress failed"):
         await loop._run_agent_loop(
-            TranscriptInput(history=[], current_message=None),
-            runtime=loop.llm_runtime(),
-            on_progress=bad_progress,
+            [], runtime=loop.llm_runtime(), on_progress=bad_progress
         )
 
 
@@ -599,8 +596,7 @@ async def test_agent_loop_no_hooks_backward_compat(tmp_path):
     loop.max_iterations = 2
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
-        runtime=loop.llm_runtime(),
+        [], runtime=loop.llm_runtime()
     )
     assert result.final_content == (
         "I reached the maximum number of tool call iterations (2) "

tests/agent/test_loop_concurrency.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-import pytest
-
-
-def _provider() -> MagicMock:
-    provider = MagicMock()
-    provider.get_default_model.return_value = "test-model"
-    provider.generation = SimpleNamespace(
-        max_tokens=4096,
-        temperature=0.1,
-        reasoning_effort=None,
-    )
-    return provider
-
-
-def test_request_concurrency_is_unlimited_by_default(
-    monkeypatch: pytest.MonkeyPatch,
-    loop_factory,
-) -> None:
-    monkeypatch.delenv("NANOBOT_MAX_CONCURRENT_REQUESTS", raising=False)
-
-    loop = loop_factory(provider=_provider(), patch_deps=True)
-
-    assert loop._concurrency_gate is None
-
-
-@pytest.mark.asyncio
-async def test_positive_request_concurrency_keeps_explicit_cap(
-    monkeypatch: pytest.MonkeyPatch,
-    loop_factory,
-) -> None:
-    monkeypatch.setenv("NANOBOT_MAX_CONCURRENT_REQUESTS", "2")
-    loop = loop_factory(provider=_provider(), patch_deps=True)
-    gate = loop._concurrency_gate
-
-    assert gate is not None
-    for _ in range(2):
-        await gate.acquire()
-    try:
-        assert gate.locked()
-    finally:
-        for _ in range(2):
-            gate.release()

tests/agent/test_loop_consolidation_tokens.py

@@ -2,26 +2,17 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
+import nanobot.agent.memory as memory_module
 from nanobot.agent.loop import AgentLoop
 from nanobot.bus.queue import MessageBus
-from nanobot.providers.base import (
-    GenerationSettings,
-    LLMResponse,
-    ProviderConversationState,
-)
-from nanobot.session.summary import SUMMARY_CONTINUATION_TEXT
+from nanobot.providers.base import LLMResponse
 
 
-def _make_loop(
-    tmp_path,
-    *,
-    estimated_tokens: int,
-    context_window_tokens: int,
-    max_tokens: int = 0,
-) -> AgentLoop:
+def _make_loop(tmp_path, *, estimated_tokens: int, context_window_tokens: int) -> AgentLoop:
+    from nanobot.providers.base import GenerationSettings
     provider = MagicMock()
     provider.get_default_model.return_value = "test-model"
-    provider.generation = GenerationSettings(max_tokens=max_tokens)
+    provider.generation = GenerationSettings(max_tokens=0)
     provider.estimate_prompt_tokens.return_value = (estimated_tokens, "test-counter")
     _response = LLMResponse(content="ok", tool_calls=[])
     provider.chat_with_retry = AsyncMock(return_value=_response)
@@ -33,9 +24,6 @@ def _make_loop(
         workspace=tmp_path,
         model="test-model",
         context_window_tokens=context_window_tokens,
-        # These tests isolate Memory consolidation; Runner request fitting is
-        # covered separately with realistic context windows.
-        context_block_limit=10_000,
     )
     loop.tools.get_definitions = MagicMock(return_value=[])
     loop.consolidator._SAFETY_BUFFER = 0
@@ -43,108 +31,249 @@ def _make_loop(
 
 
 @pytest.mark.asyncio
-async def test_runner_pressure_commits_summary_and_current_delta(tmp_path) -> None:
-    loop = _make_loop(tmp_path, estimated_tokens=100, context_window_tokens=2_000)
-    loop.context_block_limit = 500
-    loop.provider.generation = GenerationSettings(max_tokens=100)
-    loop.provider.can_resume_conversation_state.return_value = False
+async def test_prompt_below_threshold_does_not_consolidate(tmp_path) -> None:
+    loop = _make_loop(tmp_path, estimated_tokens=100, context_window_tokens=200)
+    loop.consolidator.archive_session = AsyncMock(return_value=True)  # type: ignore[method-assign]
+
+    await loop.process_direct("hello", session_key="cli:test")
+
+    loop.consolidator.archive_session.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_prompt_above_threshold_triggers_consolidation(tmp_path, monkeypatch) -> None:
+    loop = _make_loop(tmp_path, estimated_tokens=1000, context_window_tokens=200)
+    loop.consolidator.archive_session = AsyncMock(return_value=True)  # type: ignore[method-assign]
+    session = loop.sessions.get_or_create("cli:test")
+    session.messages = [
+        {"role": "user", "content": "u1", "timestamp": "2026-01-01T00:00:00"},
+        {"role": "assistant", "content": "a1", "timestamp": "2026-01-01T00:00:01"},
+        {"role": "user", "content": "u2", "timestamp": "2026-01-01T00:00:02"},
+    ]
+    loop.sessions.save(session)
+    monkeypatch.setattr(memory_module, "estimate_message_tokens", lambda _message: 500)
+
+    await loop.process_direct("hello", session_key="cli:test")
+
+    assert loop.consolidator.archive_session.await_count >= 1
+
+
+@pytest.mark.asyncio
+async def test_prompt_above_threshold_archives_until_next_user_boundary(tmp_path, monkeypatch) -> None:
+    loop = _make_loop(tmp_path, estimated_tokens=1000, context_window_tokens=200)
+    loop.consolidator.archive_session = AsyncMock(return_value=True)  # type: ignore[method-assign]
+
+    session = loop.sessions.get_or_create("cli:test")
+    session.messages = [
+        {"role": "user", "content": "u1", "timestamp": "2026-01-01T00:00:00"},
+        {"role": "assistant", "content": "a1", "timestamp": "2026-01-01T00:00:01"},
+        {"role": "user", "content": "u2", "timestamp": "2026-01-01T00:00:02"},
+        {"role": "assistant", "content": "a2", "timestamp": "2026-01-01T00:00:03"},
+        {"role": "user", "content": "u3", "timestamp": "2026-01-01T00:00:04"},
+    ]
+    loop.sessions.save(session)
+
+    token_map = {"u1": 120, "a1": 120, "u2": 120, "a2": 120, "u3": 120}
+    monkeypatch.setattr(memory_module, "estimate_message_tokens", lambda message: token_map[message["content"]])
+
+    await loop.consolidator.maybe_consolidate_by_tokens(
+        session,
+        runtime=loop.llm_runtime(),
+    )
+
+    archive_end = loop.consolidator.archive_session.await_args.kwargs["archive_end"]
+    archived_chunk = session.messages[:archive_end]
+    assert [message["content"] for message in archived_chunk] == ["u1", "a1", "u2", "a2"]
+    assert session.last_consolidated == 4
+
+
+@pytest.mark.asyncio
+async def test_consolidation_loops_until_target_met(tmp_path, monkeypatch) -> None:
+    """Verify maybe_consolidate_by_tokens keeps looping until under threshold."""
+    loop = _make_loop(tmp_path, estimated_tokens=0, context_window_tokens=200)
+    loop.consolidator.archive_session = AsyncMock(return_value=True)  # type: ignore[method-assign]
+
+    session = loop.sessions.get_or_create("cli:test")
+    session.messages = [
+        {"role": "user", "content": "u1", "timestamp": "2026-01-01T00:00:00"},
+        {"role": "assistant", "content": "a1", "timestamp": "2026-01-01T00:00:01"},
+        {"role": "user", "content": "u2", "timestamp": "2026-01-01T00:00:02"},
+        {"role": "assistant", "content": "a2", "timestamp": "2026-01-01T00:00:03"},
+        {"role": "user", "content": "u3", "timestamp": "2026-01-01T00:00:04"},
+        {"role": "assistant", "content": "a3", "timestamp": "2026-01-01T00:00:05"},
+        {"role": "user", "content": "u4", "timestamp": "2026-01-01T00:00:06"},
+    ]
+    loop.sessions.save(session)
+
+    call_count = [0]
+    def mock_estimate(_session, *, runtime):
+        call_count[0] += 1
+        if call_count[0] == 1:
+            return (500, "test")
+        if call_count[0] == 2:
+            return (300, "test")
+        return (80, "test")
+
+    loop.consolidator.estimate_session_prompt_tokens = mock_estimate  # type: ignore[method-assign]
+    monkeypatch.setattr(memory_module, "estimate_message_tokens", lambda _m: 100)
+
+    await loop.consolidator.maybe_consolidate_by_tokens(
+        session,
+        runtime=loop.llm_runtime(),
+    )
+
+    assert loop.consolidator.archive_session.await_count == 2
+    assert session.last_consolidated == 6
+
+
+@pytest.mark.asyncio
+async def test_consolidation_continues_below_trigger_until_half_target(tmp_path, monkeypatch) -> None:
+    """Once triggered, consolidation should continue until it drops below half threshold."""
+    loop = _make_loop(tmp_path, estimated_tokens=0, context_window_tokens=200)
+    loop.consolidator.archive_session = AsyncMock(return_value=True)  # type: ignore[method-assign]
+
+    session = loop.sessions.get_or_create("cli:test")
+    session.messages = [
+        {"role": "user", "content": "u1", "timestamp": "2026-01-01T00:00:00"},
+        {"role": "assistant", "content": "a1", "timestamp": "2026-01-01T00:00:01"},
+        {"role": "user", "content": "u2", "timestamp": "2026-01-01T00:00:02"},
+        {"role": "assistant", "content": "a2", "timestamp": "2026-01-01T00:00:03"},
+        {"role": "user", "content": "u3", "timestamp": "2026-01-01T00:00:04"},
+        {"role": "assistant", "content": "a3", "timestamp": "2026-01-01T00:00:05"},
+        {"role": "user", "content": "u4", "timestamp": "2026-01-01T00:00:06"},
+    ]
+    loop.sessions.save(session)
+
+    call_count = [0]
+
+    def mock_estimate(_session, *, runtime):
+        call_count[0] += 1
+        if call_count[0] == 1:
+            return (500, "test")
+        if call_count[0] == 2:
+            return (150, "test")
+        return (80, "test")
+
+    loop.consolidator.estimate_session_prompt_tokens = mock_estimate  # type: ignore[method-assign]
+    monkeypatch.setattr(memory_module, "estimate_message_tokens", lambda _m: 100)
+
+    await loop.consolidator.maybe_consolidate_by_tokens(
+        session,
+        runtime=loop.llm_runtime(),
+    )
+
+    assert loop.consolidator.archive_session.await_count == 2
+    assert session.last_consolidated == 6
+
+
+@pytest.mark.asyncio
+async def test_consolidation_persists_summary_for_next_prepare_session(tmp_path, monkeypatch) -> None:
+    loop = _make_loop(tmp_path, estimated_tokens=0, context_window_tokens=200)
+    loop.consolidator.archive_session = AsyncMock(return_value="User discussed project status.")  # type: ignore[method-assign]
+
+    session = loop.sessions.get_or_create("cli:test")
+    session.messages = [
+        {"role": "user", "content": "u1", "timestamp": "2026-01-01T00:00:00"},
+        {"role": "assistant", "content": "a1", "timestamp": "2026-01-01T00:00:01"},
+        {"role": "user", "content": "u2", "timestamp": "2026-01-01T00:00:02"},
+    ]
+    loop.sessions.save(session)
+
+    call_count = [0]
+
+    def mock_estimate(_session, *, runtime):
+        call_count[0] += 1
+        if call_count[0] == 1:
+            return (500, "test")
+        return (80, "test")
+
+    loop.consolidator.estimate_session_prompt_tokens = mock_estimate  # type: ignore[method-assign]
+    monkeypatch.setattr(memory_module, "estimate_message_tokens", lambda _m: 150)
+
+    await loop.consolidator.maybe_consolidate_by_tokens(
+        session,
+        runtime=loop.llm_runtime(),
+    )
+
+    reloaded = loop.sessions.get_or_create("cli:test")
+    meta = reloaded.metadata.get("_last_summary")
+    assert meta is not None
+    assert meta["text"] == "User discussed project status."
+
+    reloaded, pending = loop.auto_compact.prepare_session(reloaded, "cli:test")
+    assert pending is not None
+    assert pending["text"] == "User discussed project status."
+    # _last_summary persists for restart survival.
+    assert "_last_summary" in reloaded.metadata
+
+
+@pytest.mark.asyncio
+async def test_preflight_consolidation_receives_pending_summary(tmp_path) -> None:
+    loop = _make_loop(tmp_path, estimated_tokens=100, context_window_tokens=200)
+    session = loop.sessions.get_or_create("cli:test")
+    loop.auto_compact.prepare_session = MagicMock(
+        return_value=(
+            session,
+            {"text": "earlier context", "last_active": session.updated_at.isoformat()},
+        )
+    )  # type: ignore[method-assign]
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=None)  # type: ignore[method-assign]
+    loop.schedule_background = lambda coro: coro.close()  # type: ignore[method-assign]
+
+    runtime = loop.llm_runtime()
+    await loop.process_direct("hello", session_key="cli:test", runtime=runtime)
+
+    loop.consolidator.maybe_consolidate_by_tokens.assert_any_await(
+        session,
+        runtime=runtime,
+    )
+    assert len(loop.consolidator.maybe_consolidate_by_tokens.call_args_list) == 2
+    assert all(
+        call.kwargs["runtime"] is runtime
+        for call in loop.consolidator.maybe_consolidate_by_tokens.call_args_list
+    )
+
+
+@pytest.mark.asyncio
+async def test_preflight_consolidation_before_llm_call(tmp_path, monkeypatch) -> None:
+    """Verify preflight consolidation runs before the LLM call in process_direct."""
+    order: list[str] = []
+
+    loop = _make_loop(tmp_path, estimated_tokens=0, context_window_tokens=200)
+
+    archived_session_keys: list[str | None] = []
+
+    async def track_consolidate(session, *, archive_end, runtime):
+        order.append("consolidate")
+        archived_session_keys.append(session.key)
+        return True
+    loop.consolidator.archive_session = track_consolidate  # type: ignore[method-assign]
+
+    async def track_llm(*args, **kwargs):
+        order.append("llm")
+        return LLMResponse(content="ok", tool_calls=[])
+    loop.provider.chat_with_retry = track_llm
+    loop.provider.chat_stream_with_retry = track_llm
     loop.schedule_background = lambda coro: coro.close()  # type: ignore[method-assign]
 
     session = loop.sessions.get_or_create("cli:test")
     session.messages = [
-        {"role": role, "content": f"old-{role}-{turn}"}
-        for turn in range(6)
-        for role in ("user", "assistant")
+        {"role": "user", "content": "u1", "timestamp": "2026-01-01T00:00:00"},
+        {"role": "assistant", "content": "a1", "timestamp": "2026-01-01T00:00:01"},
+        {"role": "user", "content": "u2", "timestamp": "2026-01-01T00:00:02"},
     ]
     loop.sessions.save(session)
+    monkeypatch.setattr(memory_module, "estimate_message_tokens", lambda _m: 500)
 
-    def estimate(messages, _tools, _model):
-        contents = [str(message.get("content")) for message in messages]
-        if contents and "SNIP" in contents[-1]:
-            return 300, "test-counter"
-        if any(content.startswith("old-") for content in contents):
-            return 600, "test-counter"
-        return 100, "test-counter"
+    call_count = [0]
+    def mock_estimate(_session, *, runtime):
+        call_count[0] += 1
+        return (1000 if call_count[0] <= 1 else 80, "test")
+    loop.consolidator.estimate_session_prompt_tokens = mock_estimate  # type: ignore[method-assign]
 
-    loop.provider.estimate_prompt_tokens.side_effect = estimate
-    loop.provider.chat_with_retry = AsyncMock(side_effect=[
-        LLMResponse(content="Current checkpoint.", tool_calls=[]),
-        LLMResponse(content="done", tool_calls=[]),
-    ])
+    await loop.process_direct("hello", session_key="cli:test")
 
-    result = await loop.process_direct("continue the task", session_key="cli:test")
-
-    assert result.content == "done"
-    assert loop.provider.chat_with_retry.await_count == 2
-    model_request = loop.provider.chat_with_retry.await_args_list[1].kwargs["messages"]
-    assert "Current checkpoint." in model_request[0]["content"]
-    assert model_request[1]["content"] == SUMMARY_CONTINUATION_TEXT
-    assert model_request[2]["content"] == "continue the task"
-
-    reloaded = loop.sessions.get_or_create("cli:test")
-    assert reloaded.messages[0]["content"] == "old-user-0"
-    assert reloaded.metadata["_last_summary"]["text"] == "Current checkpoint."
-    assert reloaded.messages[reloaded.last_archived]["content"] == (
-        SUMMARY_CONTINUATION_TEXT
-    )
-    assert [message["content"] for message in reloaded.get_history()] == [
-        SUMMARY_CONTINUATION_TEXT,
-        "continue the task",
-        "done",
-    ]
-
-
-@pytest.mark.asyncio
-async def test_native_provider_compaction_commits_portable_terminal_checkpoint(
-    tmp_path,
-) -> None:
-    loop = _make_loop(tmp_path, estimated_tokens=100, context_window_tokens=2_000)
-    session = loop.sessions.get_or_create("cli:native")
-    session.messages = [
-        {"role": "user", "content": "accepted history"},
-        {"role": "assistant", "content": "accepted answer"},
-    ]
-    loop.sessions.save(session)
-    compacted_state = ProviderConversationState(
-        kind="openai_responses",
-        provider="openai:test",
-        model="test-model",
-        version=1,
-        payload={"items": [{"type": "compaction", "encrypted_content": "opaque"}]},
-    )
-    loop.provider.can_resume_conversation_state.return_value = True
-    loop.provider.chat_with_retry = AsyncMock(return_value=LLMResponse(
-        content="done",
-        provider_state=compacted_state,
-        provider_compaction_applied=True,
-        provider_compaction_state=compacted_state,
-        provider_compaction_scope="current_request",
-    ))
-    loop.consolidator.summarize_provider_compaction = AsyncMock(
-        return_value="portable terminal checkpoint",
-    )
-
-    result = await loop.process_direct("continue", session_key="cli:native")
-
-    assert result.content == "done"
-    summarize = loop.consolidator.summarize_provider_compaction
-    summarize.assert_awaited_once()
-    assert summarize.await_args.args[0] == compacted_state
-    accepted = summarize.await_args.args[1]
-    accepted_contents = [message.get("content") for message in accepted]
-    assert "accepted history" in accepted_contents
-    assert "accepted answer" in accepted_contents
-    assert "continue" in accepted_contents
-    assert "done" not in accepted_contents
-    reloaded = loop.sessions.get_or_create("cli:native")
-    assert reloaded.provider_state is None
-    assert reloaded.metadata["_last_summary"]["text"] == (
-        "portable terminal checkpoint"
-    )
-    assert reloaded.messages[reloaded.last_archived]["content"] == (
-        SUMMARY_CONTINUATION_TEXT
-    )
-    assert [message["content"] for message in reloaded.get_history()] == [
-        SUMMARY_CONTINUATION_TEXT,
-        "done",
-    ]
+    assert "consolidate" in order
+    assert "llm" in order
+    assert order.index("consolidate") < order.index("llm")
+    assert archived_session_keys == ["cli:test"]

tests/agent/test_loop_image_generation_media.py

@@ -69,6 +69,7 @@ async def test_outbound_no_longer_carries_generated_media(
         ),
         image_generation_provider_config=ProviderConfig(api_key="sk-or-test"),
     )
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     result = await loop._process_message(
         InboundMessage(

tests/agent/test_loop_progress.py

@@ -6,7 +6,6 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from nanobot.agent.context import TranscriptInput
 from nanobot.agent.hooks import create_file_edit_activity_hook
 from nanobot.agent.loop import AgentLoop
 from nanobot.agent.tools.context import current_request_context
@@ -85,9 +84,7 @@ class TestToolEventProgress:
             progress.append((content, tool_hint, tool_events))
 
         result = await loop._run_agent_loop(
-            TranscriptInput(history=[], current_message=None),
-            runtime=loop.llm_runtime(),
-            on_progress=on_progress,
+            [], runtime=loop.llm_runtime(), on_progress=on_progress
         )
 
         assert result.final_content == "Done"
@@ -158,9 +155,7 @@ class TestToolEventProgress:
                 file_events.extend(file_edit_events)
 
         result = await loop._run_agent_loop(
-            TranscriptInput(history=[], current_message=None),
-            runtime=loop.llm_runtime(),
-            on_progress=on_progress,
+            [], runtime=loop.llm_runtime(), on_progress=on_progress
         )
 
         assert result.final_content == "Done"
@@ -230,9 +225,7 @@ class TestToolEventProgress:
         )
 
         result = await loop._run_agent_loop(
-            TranscriptInput(history=[], current_message=None),
-            runtime=loop.llm_runtime(),
-            on_progress=on_progress,
+            [], runtime=loop.llm_runtime(), on_progress=on_progress
         )
 
         assert result.final_content == "Done"
@@ -270,9 +263,7 @@ class TestToolEventProgress:
                 file_events.extend(file_edit_events)
 
         await loop._run_agent_loop(
-            TranscriptInput(history=[], current_message=None),
-            runtime=loop.llm_runtime(),
-            on_progress=on_progress,
+            [], runtime=loop.llm_runtime(), on_progress=on_progress
         )
 
         assert file_events == []
@@ -382,6 +373,7 @@ class TestToolEventProgress:
         """The /goal command rewrites the prompt but must not bypass WebUI file-edit progress."""
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "test-model"
         call_count = 0
 
@@ -425,6 +417,7 @@ class TestToolEventProgress:
                 None,
             ),
         )
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -467,11 +460,13 @@ class TestToolEventProgress:
         """Non-streaming channels should get one final reply, not token progress spam."""
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "openai-codex/gpt-5.5"
         provider.chat_with_retry = AsyncMock(return_value=LLMResponse(content="Hello", tool_calls=[]))
         provider.chat_stream_with_retry = AsyncMock()
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="openai-codex/gpt-5.5")
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="whatsapp",
@@ -498,6 +493,7 @@ class TestToolEventProgress:
         """Streaming channels still receive provider deltas through stream events."""
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "openai-codex/gpt-5.5"
 
         async def chat_stream_with_retry(*, on_content_delta, **kwargs):
@@ -510,6 +506,7 @@ class TestToolEventProgress:
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="openai-codex/gpt-5.5")
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -547,6 +544,7 @@ class TestToolEventProgress:
     ) -> None:
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "test-model"
         responses = iter([
             LLMResponse(content="first-", finish_reason="length"),
@@ -563,6 +561,7 @@ class TestToolEventProgress:
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -591,6 +590,7 @@ class TestToolEventProgress:
     ) -> None:
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "test-model"
         call_count = 0
 
@@ -607,6 +607,7 @@ class TestToolEventProgress:
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -636,6 +637,7 @@ class TestToolEventProgress:
     ) -> None:
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "test-model"
 
         async def chat_stream_with_retry(*, on_content_delta, **kwargs):
@@ -650,6 +652,7 @@ class TestToolEventProgress:
         _attach_webui_runtime_events(loop, bus)
         loop.max_iterations = 1
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -725,6 +728,7 @@ class TestToolEventProgress:
         """A no-tools finalization must not be dropped after empty stream retries."""
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "openai-codex/gpt-5.5"
         provider.chat_stream_with_retry = AsyncMock(side_effect=[
             LLMResponse(content=None, tool_calls=[]),
@@ -741,6 +745,7 @@ class TestToolEventProgress:
         )
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -771,6 +776,7 @@ class TestToolEventProgress:
     ) -> None:
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "openai-codex/gpt-5.5"
         first_request_started = asyncio.Event()
         release_first_request = asyncio.Event()
@@ -808,6 +814,9 @@ class TestToolEventProgress:
             return "ok"
 
         loop.tools.execute = execute_tool
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(  # type: ignore[method-assign]
+            return_value=False
+        )
 
         session_key = "websocket:chat-a"
         session = loop.sessions.get_or_create(session_key)
@@ -926,6 +935,7 @@ class TestToolEventProgress:
         """Recovered streaming output should use a new stream segment."""
         bus = MessageBus()
         provider = MagicMock()
+        provider.supports_progress_deltas = True
         provider.get_default_model.return_value = "openai-codex/gpt-5.5"
 
         async def chat_stream_with_retry(*, on_content_delta, on_stream_recover, **kwargs):
@@ -939,6 +949,7 @@ class TestToolEventProgress:
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="openai-codex/gpt-5.5")
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -977,12 +988,13 @@ class TestToolEventProgress:
         provider.chat_with_retry.assert_not_awaited()
 
     @pytest.mark.asyncio
-    async def test_streamed_content_is_not_repeated_before_tool_execution(
+    async def test_streamed_progress_is_not_repeated_before_tool_execution(
         self,
         tmp_path: Path,
     ) -> None:
-        """If content was already streamed, tool setup should not repeat it."""
+        """If content was already streamed as progress, tool setup should not repeat it."""
         loop = _make_loop(tmp_path)
+        loop.provider.supports_progress_deltas = True
         tool_call = ToolCallRequest(id="call1", name="custom_tool", arguments={"path": "foo.txt"})
         calls = iter([
             LLMResponse(content="I will inspect it.", tool_calls=[tool_call]),
@@ -1017,7 +1029,7 @@ class TestToolEventProgress:
             progress.append((content, tool_hint, tool_events))
 
         result = await loop._run_agent_loop(
-            TranscriptInput(history=[], current_message=None),
+            [],
             runtime=loop.llm_runtime(),
             on_progress=on_progress,
             on_stream=on_stream,
@@ -1037,6 +1049,7 @@ class TestToolEventProgress:
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="websocket",
@@ -1120,6 +1133,7 @@ class TestToolEventProgress:
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await asyncio.wait_for(loop._dispatch(InboundMessage(
             channel="websocket",
@@ -1168,6 +1182,7 @@ class TestToolEventProgress:
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")
         _attach_webui_runtime_events(loop, bus)
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         captured: dict[str, object] = {}
 
@@ -1254,6 +1269,7 @@ class TestToolEventProgress:
         provider.chat_with_retry = AsyncMock(return_value=LLMResponse(content="Done", tool_calls=[]))
         loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")
         loop.tools.get_definitions = MagicMock(return_value=[])
+        loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
         await loop._dispatch(InboundMessage(
             channel="slack",

tests/agent/test_loop_runner_integration.py

@@ -7,7 +7,6 @@ from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
-from nanobot.agent.context import TranscriptInput
 from nanobot.agent.goal_permission import goal_mutation_allowed, goal_mutation_permission
 from nanobot.agent.tools.context import RequestContext
 from nanobot.bus.outbound_events import StreamedResponseEvent
@@ -56,7 +55,7 @@ async def test_ephemeral_runner_enters_and_restores_turn_scopes(tmp_path):
     loop.tools.get_definitions = MagicMock(return_value=[])
 
     await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
+        [],
         runtime=loop.llm_runtime(),
         ephemeral=True,
         turn_scopes=[goal_mutation_permission(True)],
@@ -112,6 +111,7 @@ async def test_goal_command_can_implement_plan_from_prior_discussion(tmp_path):
         LLMResponse(content="done", tool_calls=[], usage=None),
     ])
     loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=None)
     session = loop.sessions.get_or_create("cli:direct")
     session.add_message("user", "Let's agree on the migration implementation.")
     session.add_message("assistant", "Use the staged migration plan and run integration tests.")
@@ -165,6 +165,7 @@ async def test_runtime_context_is_persisted_as_next_turn_prompt_prefix(tmp_path)
         LLMResponse(content="second answer", usage=None),
     ])
     loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=None)
     session = loop.sessions.get_or_create("cli:direct")
     provider_calls: list[str | None] = []
 
@@ -218,6 +219,7 @@ async def test_webui_quote_reaches_model_without_leaking_into_public_history(tmp
     provider.generation = GenerationSettings()
     provider.chat_with_retry = AsyncMock(return_value=LLMResponse(content="answer", usage=None))
     loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=None)
     session = loop.sessions.get_or_create("websocket:chat")
     quote = webui_quote_runtime_context({
         WEBUI_QUOTE_METADATA: "the selected answer excerpt",
@@ -262,6 +264,7 @@ async def test_runtime_context_provider_runs_once_across_tool_iterations(tmp_pat
         LLMResponse(content="done", usage=None),
     ])
     loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=None)
     provider_calls = 0
 
     async def provide_context(_request):
@@ -306,6 +309,7 @@ async def test_non_goal_direct_turn_cannot_reuse_prior_goal_command(tmp_path):
         LLMResponse(content="handled as a one-time task", tool_calls=[], usage=None),
     ])
     loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=None)
     session = loop.sessions.get_or_create("api:default")
     session.add_message("user", "/goal old completed request")
     session.add_message("assistant", "The old request is complete.")
@@ -336,8 +340,7 @@ async def test_loop_max_iterations_message_stays_stable(tmp_path):
     loop.max_iterations = 2
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
-        runtime=loop.llm_runtime(),
+        [], runtime=loop.llm_runtime()
     )
 
     assert result.final_content == (
@@ -359,7 +362,7 @@ async def test_loop_goal_turn_uses_standard_iteration_budget(tmp_path):
 
     runtime = loop.llm_runtime()
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
+        [],
         runtime=runtime,
         request_context=RequestContext(
             channel="cli",
@@ -398,7 +401,7 @@ async def test_loop_stream_filter_handles_think_only_prefix_without_crashing(tmp
         endings.append(resuming)
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
+        [],
         runtime=loop.llm_runtime(),
         on_stream=on_stream,
         on_stream_end=on_stream_end,
@@ -425,9 +428,7 @@ async def test_loop_stream_filter_hides_partial_trailing_think_prefix(tmp_path):
         deltas.append(delta)
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
-        runtime=loop.llm_runtime(),
-        on_stream=on_stream,
+        [], runtime=loop.llm_runtime(), on_stream=on_stream
     )
 
     assert result.final_content == "Hello World"
@@ -450,9 +451,7 @@ async def test_loop_stream_filter_hides_complete_trailing_think_tag(tmp_path):
         deltas.append(delta)
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
-        runtime=loop.llm_runtime(),
-        on_stream=on_stream,
+        [], runtime=loop.llm_runtime(), on_stream=on_stream
     )
 
     assert result.final_content == "Hello World"
@@ -473,8 +472,7 @@ async def test_loop_retries_think_only_final_response(tmp_path):
     loop.provider.chat_with_retry = chat_with_retry
 
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
-        runtime=loop.llm_runtime(),
+        [], runtime=loop.llm_runtime()
     )
 
     assert result.final_content == "Recovered answer"
@@ -584,6 +582,7 @@ async def test_next_turn_after_llm_error_keeps_turn_boundary(tmp_path):
 
     loop = AgentLoop(bus=MessageBus(), provider=provider, workspace=tmp_path, model="test-model")
     loop.tools.get_definitions = MagicMock(return_value=[])
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     first = await loop._process_message(
         InboundMessage(channel="cli", sender_id="user", chat_id="test", content="first question")

tests/agent/test_loop_save_turn.py

@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock, MagicMock
 import pytest
 from loguru import logger
 
-from nanobot.agent.context import ContextBuilder, TranscriptInput
+from nanobot.agent.context import ContextBuilder
 from nanobot.agent.loop import AgentLoop
 from nanobot.agent.runner import AgentRunResult
 from nanobot.agent.tools.context import RequestContext, request_context
@@ -45,10 +45,6 @@ from nanobot.session.recovery import (
     RUNTIME_CHECKPOINT_KEY,
     restore_runtime_checkpoint,
 )
-from nanobot.session.summary import (
-    SUMMARY_CONTINUATION_TEXT,
-    SessionSummaryCheckpoint,
-)
 from nanobot.session.turn_continuation import (
     INTERNAL_CONTINUATION_META,
     INTERNAL_CONTINUATION_RUN_STARTED_AT_META,
@@ -83,13 +79,6 @@ def _agent_run_result(
     )
 
 
-def _assembled_messages(
-    builder: ContextBuilder,
-    transcript_input: TranscriptInput,
-) -> list[dict]:
-    return builder.build_transcript(transcript_input, include_memory=False)
-
-
 def _mk_loop() -> AgentLoop:
     loop = AgentLoop.__new__(AgentLoop)
     from nanobot.config.schema import AgentDefaults
@@ -510,60 +499,6 @@ def test_save_turn_keeps_multimodal_runtime_context_for_model_replay() -> None:
     assert public_history_message(session.messages[0])["content"] == []
 
 
-def test_save_turn_commits_summary_boundary_without_rewriting_raw_history() -> None:
-    loop = _mk_loop()
-    session = Session(key="test:summary-checkpoint")
-    session.add_message("user", "inspect the project")
-    messages = [
-        {"role": "system", "content": "system"},
-        {"role": "user", "content": "inspect the project"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [{
-                "id": "call-1",
-                "type": "function",
-                "function": {"name": "inspect", "arguments": "{}"},
-            }],
-        },
-        {
-            "role": "tool",
-            "tool_call_id": "call-1",
-            "name": "inspect",
-            "content": "full current result",
-        },
-        {"role": "assistant", "content": "done"},
-    ]
-
-    loop._save_turn(
-        session,
-        messages,
-        skip=2,
-        summary_checkpoint=SessionSummaryCheckpoint(
-            summary="Current working-memory checkpoint.",
-            transcript_boundary=2,
-        ),
-        input_persisted_early=True,
-    )
-
-    assert [message["role"] for message in session.messages] == [
-        "user", "user", "assistant", "tool", "assistant",
-    ]
-    assert session.messages[0]["content"] == "inspect the project"
-    assert session.messages[1]["content"] == SUMMARY_CONTINUATION_TEXT
-    assert session.messages[1]["_hidden_history"] is True
-    assert session.last_archived == 1
-    assert session.metadata["_last_summary"]["text"] == (
-        "Current working-memory checkpoint."
-    )
-    assert [message["content"] for message in session.get_history()] == [
-        SUMMARY_CONTINUATION_TEXT,
-        "",
-        "full current result",
-        "done",
-    ]
-
-
 def test_save_turn_acknowledges_every_merged_recovery_followup() -> None:
     """Persisting a merged injected row retires every durable follow-up ID."""
     loop = _mk_loop()
@@ -995,13 +930,10 @@ async def test_runtime_checkpoint_keeps_provider_state_out_of_public_metadata(
     session = loop.sessions.get_or_create("cli:private-checkpoint")
 
     await loop._run_agent_loop(
-        TranscriptInput(
-            history=[
-                {"role": "system", "content": "system"},
-                {"role": "user", "content": "question"},
-            ],
-            current_message=None,
-        ),
+        [
+            {"role": "system", "content": "system"},
+            {"role": "user", "content": "question"},
+        ],
         runtime=loop.llm_runtime(),
         session=session,
     )
@@ -1024,6 +956,7 @@ async def test_runtime_checkpoint_keeps_provider_state_out_of_public_metadata(
 @pytest.mark.asyncio
 async def test_process_message_persists_user_message_before_turn_completes(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop._run_agent_loop = AsyncMock(side_effect=RuntimeError("boom"))  # type: ignore[method-assign]
 
     msg = InboundMessage(channel="feishu", sender_id="u1", chat_id="c1", content="persist me")
@@ -1043,6 +976,7 @@ async def test_subagent_followup_stages_provider_state_before_turn_runs(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop._run_agent_loop = AsyncMock(side_effect=RuntimeError("boom"))  # type: ignore[method-assign]
     loop.provider.can_resume_conversation_state.return_value = True
     session = loop.sessions.get_or_create("cli:subagent-crash")
@@ -1072,8 +1006,9 @@ async def test_subagent_followup_state_is_durable_before_prompt_assembly(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop.provider.can_resume_conversation_state.return_value = True
-    loop.context.build_system_prompt = MagicMock(  # type: ignore[method-assign]
+    loop._build_initial_messages = MagicMock(  # type: ignore[method-assign]
         side_effect=RuntimeError("prompt boom"),
     )
     session = loop.sessions.get_or_create("cli:subagent-prompt-crash")
@@ -1104,9 +1039,10 @@ async def test_subagent_redelivery_does_not_duplicate_staged_provider_input(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop.provider.can_resume_conversation_state.return_value = True
-    build_system_prompt = loop.context.build_system_prompt
-    loop.context.build_system_prompt = MagicMock(  # type: ignore[method-assign]
+    build_initial_messages = loop._build_initial_messages
+    loop._build_initial_messages = MagicMock(  # type: ignore[method-assign]
         side_effect=RuntimeError("prompt boom"),
     )
     session = loop.sessions.get_or_create("cli:subagent-redelivery")
@@ -1130,7 +1066,7 @@ async def test_subagent_redelivery_does_not_duplicate_staged_provider_input(
         message.get("content")
         for message in persisted.provider_state.pending_messages
     ].count("subagent result") == 1
-    loop.context.build_system_prompt = build_system_prompt  # type: ignore[method-assign]
+    loop._build_initial_messages = build_initial_messages  # type: ignore[method-assign]
     loop._run_agent_loop = AsyncMock(  # type: ignore[method-assign]
         side_effect=RuntimeError("provider boom"),
     )
@@ -1155,6 +1091,7 @@ async def test_subagent_followup_clears_state_before_compatibility_failure(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop.provider.can_resume_conversation_state.side_effect = RuntimeError(
         "compatibility boom"
     )
@@ -1182,6 +1119,7 @@ async def test_subagent_followup_clears_state_before_compatibility_failure(
 async def test_process_message_persists_unified_session_delivery_route(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
     loop._unified_session = True
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop._run_agent_loop = AsyncMock(side_effect=RuntimeError("boom"))  # type: ignore[method-assign]
 
     msg = InboundMessage(
@@ -1282,6 +1220,7 @@ async def test_process_message_persists_media_paths_on_user_turn(tmp_path: Path)
     img_b.write_bytes(_PNG_1X1)
 
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop._run_agent_loop = AsyncMock(side_effect=RuntimeError("interrupt"))  # type: ignore[method-assign]
 
     msg = InboundMessage(
@@ -1313,6 +1252,7 @@ async def test_process_message_persists_media_only_turn_without_text(tmp_path: P
     img.write_bytes(_PNG_1X1)
 
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop._run_agent_loop = AsyncMock(side_effect=RuntimeError("boom"))  # type: ignore[method-assign]
 
     msg = InboundMessage(
@@ -1336,6 +1276,7 @@ async def test_process_message_persists_media_only_turn_without_text(tmp_path: P
 @pytest.mark.asyncio
 async def test_process_message_does_not_duplicate_early_persisted_user_message(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop._run_agent_loop = AsyncMock(return_value=_agent_run_result(
         "done",
         [
@@ -1368,6 +1309,7 @@ async def test_internal_continuation_queues_turn_without_fake_user_history(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     session = loop.sessions.get_or_create("feishu:c-auto")
     session.metadata[GOAL_STATE_KEY] = {
         "status": "active",
@@ -1377,8 +1319,7 @@ async def test_internal_continuation_queues_turn_without_fake_user_history(
 
     calls: list[dict] = []
 
-    async def fake_run_agent_loop(transcript_input, *, metadata=None, **_kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def fake_run_agent_loop(initial_messages, *, metadata=None, **_kwargs):
         calls.append({"initial_messages": initial_messages, "metadata": metadata})
         if len(calls) == 1:
             return _agent_run_result(
@@ -1436,6 +1377,7 @@ async def test_internal_continuation_preserves_streaming_route_metadata(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     session = loop.sessions.get_or_create("feishu:c-stream")
     session.metadata[GOAL_STATE_KEY] = {
         "status": "active",
@@ -1445,9 +1387,8 @@ async def test_internal_continuation_preserves_streaming_route_metadata(
 
     calls = 0
 
-    async def fake_run_agent_loop(transcript_input, *, on_stream=None, on_stream_end=None, **_kwargs):
+    async def fake_run_agent_loop(initial_messages, *, on_stream=None, on_stream_end=None, **_kwargs):
         nonlocal calls
-        initial_messages = _assembled_messages(loop.context, transcript_input)
         calls += 1
         if calls == 1:
             return _agent_run_result(
@@ -1509,6 +1450,7 @@ async def test_websocket_internal_continuation_keeps_single_visible_run(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     session = loop.sessions.get_or_create("websocket:c-auto")
     session.metadata[GOAL_STATE_KEY] = {
         "status": "active",
@@ -1518,9 +1460,8 @@ async def test_websocket_internal_continuation_keeps_single_visible_run(
 
     calls = 0
 
-    async def fake_run_agent_loop(transcript_input, **_kwargs):
+    async def fake_run_agent_loop(initial_messages, **_kwargs):
         nonlocal calls
-        initial_messages = _assembled_messages(loop.context, transcript_input)
         calls += 1
         if calls == 1:
             return _agent_run_result(
@@ -1572,6 +1513,7 @@ async def test_websocket_internal_continuation_keeps_single_visible_run(
 @pytest.mark.asyncio
 async def test_process_message_keeps_delivery_chat_for_thread_session(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop.context.build_messages = MagicMock(  # type: ignore[method-assign]
         return_value=[
             {"role": "system", "content": "system"},
@@ -1610,6 +1552,7 @@ async def test_process_message_uses_explicit_session_for_goal_context(
     tmp_path: Path,
 ) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     chat_session = loop.sessions.get_or_create("websocket:chat-with-goal")
     chat_session.metadata[GOAL_STATE_KEY] = {
         "status": "active",
@@ -1680,7 +1623,7 @@ async def test_run_agent_loop_continuation_reads_latest_goal_metadata(
 
     runtime = loop.llm_runtime()
     await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
+        [],
         runtime=runtime,
         session=session,
         request_context=RequestContext(
@@ -1757,6 +1700,7 @@ async def test_request_context_uses_effective_key_for_spawn_tool(tmp_path: Path)
 @pytest.mark.asyncio
 async def test_next_turn_after_crash_closes_pending_user_turn_before_new_input(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     loop.provider.chat_with_retry = AsyncMock(return_value=MagicMock())  # unused because _run_agent_loop is stubbed
 
     session = loop.sessions.get_or_create("feishu:c3")
@@ -1805,10 +1749,11 @@ async def test_stop_preserves_runtime_checkpoint_for_next_turn(tmp_path: Path) -
     from nanobot.command.router import CommandContext
 
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     checkpoint_saved = asyncio.Event()
 
-    async def interrupted_run_agent_loop(_transcript_input, *, session=None, **_kwargs):
+    async def interrupted_run_agent_loop(_initial_messages, *, session=None, **_kwargs):
         assert session is not None
         loop._set_runtime_checkpoint(
             session,
@@ -1868,8 +1813,7 @@ async def test_stop_preserves_runtime_checkpoint_for_next_turn(tmp_path: Path) -
     assert interrupted.metadata.get(AgentLoop._PENDING_USER_TURN_KEY) is True
     assert interrupted.metadata.get(AgentLoop._RUNTIME_CHECKPOINT_KEY) is not None
 
-    async def resumed_run_agent_loop(transcript_input, **_kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def resumed_run_agent_loop(initial_messages, **_kwargs):
         return _agent_run_result(
             "next answer",
             [*initial_messages, {"role": "assistant", "content": "next answer"}],
@@ -1908,6 +1852,7 @@ async def test_stop_preserves_runtime_checkpoint_for_next_turn(tmp_path: Path) -
 @pytest.mark.asyncio
 async def test_system_subagent_followup_is_persisted_before_prompt_assembly(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     session = loop.sessions.get_or_create("cli:test")
     session.add_message("user", "question")
@@ -1919,8 +1864,7 @@ async def test_system_subagent_followup_is_persisted_before_prompt_assembly(tmp_
     record_runtime = MagicMock(wraps=loop.runtime_event_publisher.record_turn_runtime)
     loop.runtime_event_publisher.record_turn_runtime = record_runtime
 
-    async def fake_run_agent_loop(transcript_input, **kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def fake_run_agent_loop(initial_messages, **kwargs):
         seen["initial_messages"] = initial_messages
         seen["runtime"] = kwargs["runtime"]
         seen["request_context"] = kwargs["request_context"]
@@ -1954,6 +1898,11 @@ async def test_system_subagent_followup_is_persisted_before_prompt_assembly(tmp_
     assert request.metadata == {"subagent_task_id": "sub-1"}
     assert request.turn_id
     record_runtime.assert_called_once_with("cli:test", runtime)
+    assert len(loop.consolidator.maybe_consolidate_by_tokens.call_args_list) == 2
+    assert all(
+        call.kwargs["runtime"] is runtime
+        for call in loop.consolidator.maybe_consolidate_by_tokens.call_args_list
+    )
     initial_messages = seen["initial_messages"]
     assert isinstance(initial_messages, list)
     non_system = [m for m in initial_messages if m.get("role") != "system"]
@@ -1988,10 +1937,10 @@ async def test_system_subagent_followup_is_persisted_before_prompt_assembly(tmp_
 @pytest.mark.asyncio
 async def test_turn_usage_is_persisted_with_the_saved_session(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
     turn_usage = LLMUsage.reported(input_tokens=64, output_tokens=9)
 
-    async def fake_run_agent_loop(transcript_input, **_kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def fake_run_agent_loop(initial_messages, **_kwargs):
         return _agent_run_result(
             "done",
             [*initial_messages, {"role": "assistant", "content": "done"}],
@@ -2013,9 +1962,11 @@ async def test_turn_usage_is_persisted_with_the_saved_session(tmp_path: Path) ->
 @pytest.mark.asyncio
 async def test_system_subagent_followup_does_not_log_content(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(  # type: ignore[method-assign]
+        return_value=False
+    )
 
-    async def fake_run_agent_loop(transcript_input, **_kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def fake_run_agent_loop(initial_messages, **_kwargs):
         return _agent_run_result(
             "done",
             [*initial_messages, {"role": "assistant", "content": "done"}],
@@ -2049,6 +2000,9 @@ async def test_system_subagent_followup_does_not_log_content(tmp_path: Path) ->
 @pytest.mark.asyncio
 async def test_system_subagent_followup_uses_common_turn_lifecycle(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(  # type: ignore[method-assign]
+        return_value=False
+    )
     visited: list[str] = []
 
     for name in (
@@ -2068,8 +2022,7 @@ async def test_system_subagent_followup_uses_common_turn_lifecycle(tmp_path: Pat
 
         setattr(loop, name, record)
 
-    async def fake_run_agent_loop(transcript_input, **_kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def fake_run_agent_loop(initial_messages, **_kwargs):
         return _agent_run_result(
             "done",
             [*initial_messages, {"role": "assistant", "content": "done"}],
@@ -2110,9 +2063,9 @@ async def test_system_subagent_followup_uses_common_turn_lifecycle(tmp_path: Pat
 @pytest.mark.asyncio
 async def test_multiple_subagent_followups_all_persist_as_standalone_history(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
-    async def fake_run_agent_loop(transcript_input, **_kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def fake_run_agent_loop(initial_messages, **_kwargs):
         return _agent_run_result(
             "ack",
             [*initial_messages, {"role": "assistant", "content": "ack"}],
@@ -2235,6 +2188,7 @@ async def test_request_context_passes_thread_session_key_to_spawn(tmp_path: Path
 @pytest.mark.asyncio
 async def test_system_subagent_followup_uses_thread_session_and_slack_metadata(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     thread_session = loop.sessions.get_or_create("slack:C123:1700.42")
     thread_session.add_message("user", "thread question")
@@ -2242,8 +2196,7 @@ async def test_system_subagent_followup_uses_thread_session_and_slack_metadata(t
 
     seen: dict[str, object] = {}
 
-    async def fake_run_agent_loop(transcript_input, **kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
+    async def fake_run_agent_loop(initial_messages, **kwargs):
         seen["initial_messages"] = initial_messages
         seen["request_context"] = kwargs["request_context"]
         return _agent_run_result(
@@ -2293,16 +2246,14 @@ async def test_system_subagent_followup_uses_thread_session_and_slack_metadata(t
 @pytest.mark.asyncio
 async def test_turn_after_unanswered_user_keeps_tool_call_pairing(tmp_path: Path) -> None:
     loop = _make_full_loop(tmp_path)
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock(return_value=False)  # type: ignore[method-assign]
 
     session = loop.sessions.get_or_create("feishu:c-merge")
     session.add_message("user", "earlier question that never got an answer")
     loop.sessions.save(session)
 
-    async def fake_run_agent_loop(transcript_input, **_kwargs):
-        initial_messages = _assembled_messages(loop.context, transcript_input)
-        assert [m["role"] for m in initial_messages] == ["system", "user", "user"]
-        assert initial_messages[-2]["content"] == "earlier question that never got an answer"
-        assert initial_messages[-1]["content"] == "and another thing"
+    async def fake_run_agent_loop(initial_messages, **_kwargs):
+        assert [m["role"] for m in initial_messages] == ["system", "user"]
         return _agent_run_result(
             "done",
             [

tests/agent/test_loop_session_policy.py

@@ -46,6 +46,7 @@ def _loop(tmp_path, responses: list[str], **kwargs) -> AgentLoop:
 async def test_transient_session_keeps_history_without_persisting_or_durable_tools(tmp_path) -> None:
     loop = _loop(tmp_path, ["first answer", "second answer"])
     loop.context.memory.write_memory("private durable memory")
+    loop.consolidator.maybe_consolidate_by_tokens = AsyncMock()
     key = "websocket:transient-test"
     loop.sessions.get_or_create_transient(
         key,
@@ -70,6 +71,7 @@ async def test_transient_session_keeps_history_without_persisting_or_durable_too
         "assistant",
     ]
     assert loop.sessions.read_session_file(key) is None
+    loop.consolidator.maybe_consolidate_by_tokens.assert_not_awaited()
 
 
 @pytest.mark.asyncio

tests/agent/test_loop_tool_context.py

@@ -5,7 +5,6 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from nanobot.agent.context import TranscriptInput
 from nanobot.agent.loop import AgentLoop
 from nanobot.agent.tools.context import (
     RequestContext,
@@ -134,7 +133,7 @@ async def test_loop_binds_request_context_for_tool_execution(tmp_path: Path) ->
     metadata = {"slack": {"thread_ts": "111.222", "channel_type": "channel"}}
     runtime = loop.llm_runtime()
     await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
+        [],
         runtime=runtime,
         request_context=RequestContext(
             channel="slack",
@@ -235,7 +234,7 @@ async def test_agent_loop_restores_outer_request_context_after_runner_exception(
     try:
         with pytest.raises(RuntimeError, match="runner failed"):
             await loop._run_agent_loop(
-                TranscriptInput(history=[], current_message=None),
+                [],
                 runtime=runtime,
                 request_context=RequestContext(
                     channel="slack",

tests/agent/test_memory_store.py

@@ -113,6 +113,54 @@ class TestHistoryWithCursor:
         entries = store.read_unprocessed_history(since_cursor=0)
         assert len(entries) == 2
 
+    def test_prompt_history_filters_to_current_session(self, store):
+        store.append_history("legacy entry without session")
+        store.append_history("telegram entry", session_key="telegram:chat-1")
+        store.append_history("slack entry", session_key="slack:chat-2")
+
+        entries = store.read_recent_history_for_prompt(
+            since_cursor=0,
+            session_key="telegram:chat-1",
+        )
+
+        assert [e["content"] for e in entries] == ["telegram entry"]
+        assert [e["content"] for e in store.read_unprocessed_history(0)] == [
+            "legacy entry without session",
+            "telegram entry",
+            "slack entry",
+        ]
+
+    def test_unified_prompt_history_excludes_internal_cron_sessions(self, store):
+        store.append_history("legacy entry without session")
+        store.append_history("unified entry", session_key="unified:default")
+        store.append_history("telegram entry", session_key="telegram:chat-1")
+        store.append_history("cron internal entry", session_key="cron:job-1")
+
+        entries = store.read_recent_history_for_prompt(
+            since_cursor=0,
+            session_key="unified:default",
+            unified_session=True,
+        )
+
+        assert [e["content"] for e in entries] == [
+            "legacy entry without session",
+            "unified entry",
+            "telegram entry",
+        ]
+
+    def test_unified_cron_prompt_history_includes_own_cron_entry(self, store):
+        store.append_history("unified entry", session_key="unified:default")
+        store.append_history("other cron entry", session_key="cron:job-2")
+        store.append_history("own cron entry", session_key="cron:job-1")
+
+        entries = store.read_recent_history_for_prompt(
+            since_cursor=0,
+            session_key="cron:job-1",
+            unified_session=True,
+        )
+
+        assert [e["content"] for e in entries] == ["unified entry", "own cron entry"]
+
     def test_read_unprocessed_skips_entries_without_cursor(self, store):
         """Regression: entries missing the cursor key should be silently skipped."""
         store.history_file.write_text(

tests/agent/test_new_command_archival.py

@@ -1,185 +0,0 @@
-"""Test /new archival behavior."""
-
-import asyncio
-from collections.abc import Coroutine
-from pathlib import Path
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from nanobot.utils.prompt_templates import render_template
-
-_ARCHIVE_PROMPT = render_template("agent/consolidator_archive.md", strip=True)
-
-
-class TestNewCommandArchival:
-    """Test /new archival behavior with the structured archive flow."""
-
-    @staticmethod
-    def _make_loop(tmp_path: Path):
-        from nanobot.agent.loop import AgentLoop
-        from nanobot.bus.queue import MessageBus
-        from nanobot.providers.base import GenerationSettings, LLMResponse
-
-        bus = MessageBus()
-        provider = MagicMock()
-        provider.get_default_model.return_value = "test-model"
-        provider.estimate_prompt_tokens.return_value = (10_000, "test")
-        provider.generation = GenerationSettings(max_tokens=100)
-        loop = AgentLoop(
-            bus=bus,
-            provider=provider,
-            workspace=tmp_path,
-            model="test-model",
-            context_window_tokens=1,
-        )
-        loop.provider.chat_with_retry = AsyncMock(
-            return_value=LLMResponse(content="ok", tool_calls=[])
-        )
-        loop.tools.get_definitions = MagicMock(return_value=[])
-        return loop
-
-    @pytest.mark.asyncio
-    async def test_new_clears_session_immediately_even_if_archive_fails(
-        self,
-        tmp_path: Path,
-    ) -> None:
-        """/new clears session immediately; archive is fire-and-forget."""
-        from nanobot.bus.events import InboundMessage
-
-        loop = self._make_loop(tmp_path)
-        session = loop.sessions.get_or_create("cli:test")
-        for i in range(5):
-            session.add_message("user", f"msg{i}")
-            session.add_message("assistant", f"resp{i}")
-        loop.sessions.save(session)
-
-        call_count = 0
-        expected_runtime = loop.llm_runtime()
-
-        async def _failing_summarize(session, *, archive_end, runtime) -> None:
-            nonlocal call_count
-            assert runtime is expected_runtime
-            assert session.key == "cli:test"
-            assert archive_end == len(session.messages)
-            call_count += 1
-
-        loop.consolidator.archive_session = _failing_summarize  # type: ignore[method-assign]
-
-        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
-        response = await loop._process_message(new_msg, runtime=expected_runtime)
-
-        assert response is not None
-        assert "new session started" in response.content.lower()
-
-        session_after = loop.sessions.get_or_create("cli:test")
-        assert len(session_after.messages) == 0
-
-        await loop.aclose()
-        assert call_count == 1
-
-    @pytest.mark.asyncio
-    async def test_new_reuses_replay_prefix_and_archives_only_unarchived_messages(
-        self,
-        tmp_path: Path,
-    ) -> None:
-        from nanobot.bus.events import InboundMessage
-
-        loop = self._make_loop(tmp_path)
-        loop.set_runtime_context_window(128_000)
-        session = loop.sessions.get_or_create("cli:test")
-        for i in range(5):
-            session.add_message("user", f"msg{i}")
-            session.add_message("assistant", f"resp{i}")
-        session.last_archived = len(session.messages) - 2
-        ordinary_history = session.get_history()
-        assert [message["content"] for message in ordinary_history] == [
-            "msg1",
-            "resp1",
-            "msg2",
-            "resp2",
-            "msg3",
-            "resp3",
-            "msg4",
-            "resp4",
-        ]
-        loop.sessions.save(session)
-
-        expected_runtime = loop.llm_runtime()
-        scheduled: list[Coroutine[Any, Any, object]] = []
-        loop.schedule_background = scheduled.append  # type: ignore[method-assign]
-
-        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
-        response = await loop._process_message(new_msg, runtime=expected_runtime)
-
-        assert response is not None
-        assert "new session started" in response.content.lower()
-
-        assert len(scheduled) == 1
-        await scheduled[0]
-        await loop.aclose()
-        sent = loop.provider.chat_with_retry.call_args.kwargs["messages"]
-        assert sent[1:-1] == ordinary_history
-        assert sent[-1]["content"] == _ARCHIVE_PROMPT
-
-    @pytest.mark.asyncio
-    async def test_new_clears_session_and_responds(self, tmp_path: Path) -> None:
-        from nanobot.bus.events import InboundMessage
-
-        loop = self._make_loop(tmp_path)
-        session = loop.sessions.get_or_create("cli:test")
-        for i in range(3):
-            session.add_message("user", f"msg{i}")
-            session.add_message("assistant", f"resp{i}")
-        loop.sessions.save(session)
-        expected_runtime = loop.llm_runtime()
-
-        async def _ok_summarize(session, *, archive_end, runtime) -> str:
-            assert runtime is expected_runtime
-            assert session.key == "cli:test"
-            assert archive_end == len(session.messages)
-            return "Summary."
-
-        loop.consolidator.archive_session = _ok_summarize  # type: ignore[method-assign]
-
-        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
-        response = await loop._process_message(new_msg, runtime=expected_runtime)
-
-        assert response is not None
-        assert "new session started" in response.content.lower()
-        assert loop.sessions.get_or_create("cli:test").messages == []
-
-    @pytest.mark.asyncio
-    async def test_aclose_drains_background_tasks(self, tmp_path: Path) -> None:
-        """aclose waits for background tasks to complete."""
-        from nanobot.bus.events import InboundMessage
-
-        loop = self._make_loop(tmp_path)
-        session = loop.sessions.get_or_create("cli:test")
-        for i in range(3):
-            session.add_message("user", f"msg{i}")
-            session.add_message("assistant", f"resp{i}")
-        loop.sessions.save(session)
-
-        archived = asyncio.Event()
-        release_archive = asyncio.Event()
-        expected_runtime = loop.llm_runtime()
-
-        async def _slow_summarize(session, *, archive_end, runtime) -> str:
-            assert runtime is expected_runtime
-            assert session.key == "cli:test"
-            assert archive_end == len(session.messages)
-            await release_archive.wait()
-            archived.set()
-            return "Summary."
-
-        loop.consolidator.archive_session = _slow_summarize  # type: ignore[method-assign]
-
-        new_msg = InboundMessage(channel="cli", sender_id="user", chat_id="test", content="/new")
-        await loop._process_message(new_msg, runtime=expected_runtime)
-
-        assert not archived.is_set()
-        release_archive.set()
-        await loop.aclose()
-        assert archived.is_set()

tests/agent/test_runner_core.py

@@ -10,8 +10,6 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import pytest
 
 from agent.runner_helpers import make_run_spec
-from nanobot.agent.context import TranscriptInput
-from nanobot.agent.context_governance import ContextWindowExceededError
 from nanobot.config.schema import AgentDefaults
 from nanobot.providers.base import (
     LLMProvider,
@@ -36,38 +34,6 @@ def _make_usage_spec(provider, tools):
     )
 
 
-def test_initial_transcript_is_built_from_structured_turn_input() -> None:
-    from nanobot.agent.runner import AgentRunner
-
-    provider = MagicMock(spec=LLMProvider)
-    transcript_input = TranscriptInput(
-        history=[{"role": "user", "content": "earlier"}],
-        current_message="fresh",
-    )
-    expected = [
-        {"role": "system", "content": "system"},
-        {"role": "user", "content": "earlier"},
-        {"role": "user", "content": "fresh"},
-    ]
-    transcript_builder = MagicMock(return_value=expected)
-    spec = make_run_spec(
-        provider,
-        initial_messages=None,
-        transcript_input=transcript_input,
-        transcript_builder=transcript_builder,
-        tools=MagicMock(),
-        model="test-model",
-        max_iterations=1,
-        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-    )
-
-    messages, compaction = AgentRunner._initial_transcript_and_compaction(spec)
-
-    assert messages == expected
-    assert compaction is None
-    transcript_builder.assert_called_once_with(transcript_input)
-
-
 def test_usage_or_estimate_replaces_reported_zero_for_content(monkeypatch) -> None:
     from nanobot.agent.runner import AgentRunner
 
@@ -90,7 +56,6 @@ def test_usage_or_estimate_replaces_reported_zero_for_content(monkeypatch) -> No
         _make_usage_spec(provider, tools),
         [{"role": "user", "content": "hello"}],
         response,
-        tool_definitions=tools.get_definitions(),
     )
 
     assert usage == LLMUsage.estimated(input_tokens=12, output_tokens=7).with_timing(
@@ -135,7 +100,6 @@ def test_usage_or_estimate_counts_tool_call_output_for_reported_zero(monkeypatch
         _make_usage_spec(provider, tools),
         [{"role": "user", "content": "hello"}],
         response,
-        tool_definitions=tools.get_definitions(),
     )
 
     assert usage == LLMUsage.estimated(input_tokens=13, output_tokens=9)
@@ -168,7 +132,6 @@ def test_usage_or_estimate_counts_error_without_estimating_tokens(
         _make_usage_spec(provider, tools),
         [{"role": "user", "content": "hello"}],
         response,
-        tool_definitions=tools.get_definitions(),
     )
 
     assert usage is not None
@@ -204,7 +167,6 @@ def test_usage_or_estimate_trusts_positive_reported_total(monkeypatch) -> None:
         _make_usage_spec(provider, tools),
         [{"role": "user", "content": "hello"}],
         response,
-        tool_definitions=tools.get_definitions(),
     )
 
     assert usage is not None
@@ -374,12 +336,14 @@ async def test_runner_replays_provider_state_without_chat_projection_duplicates(
 
 
 @pytest.mark.asyncio
-async def test_runner_preserves_tool_result_before_rejecting_unfit_followup():
+async def test_runner_governs_tool_result_before_adding_it_to_provider_state():
     from nanobot.agent.runner import AgentRunner
 
     provider = MagicMock(spec=LLMProvider)
     provider.can_resume_conversation_state.return_value = True
+    provider.supports_native_compaction.return_value = False
     calls = 0
+    captured_context: ProviderCallContext | None = None
     checkpoints: list[dict] = []
     state = ProviderConversationState(
         kind="openai_responses",
@@ -390,7 +354,7 @@ async def test_runner_preserves_tool_result_before_rejecting_unfit_followup():
     )
 
     async def chat_with_retry(**kwargs):
-        nonlocal calls
+        nonlocal calls, captured_context
         calls += 1
         if calls == 1:
             return LLMResponse(
@@ -404,6 +368,7 @@ async def test_runner_preserves_tool_result_before_rejecting_unfit_followup():
                 ],
                 provider_state=state,
             )
+        captured_context = kwargs["provider_context"]
         return LLMResponse(content="done")
 
     provider.chat_with_retry = chat_with_retry
@@ -414,36 +379,37 @@ async def test_runner_preserves_tool_result_before_rejecting_unfit_followup():
     async def checkpoint(payload: dict) -> None:
         checkpoints.append(payload)
 
-    with pytest.raises(ContextWindowExceededError):
-        await AgentRunner().run(make_run_spec(
-            provider,
-            initial_messages=[
-                {"role": "system", "content": "system"},
-                {"role": "user", "content": "read the file"},
-            ],
-            tools=tools,
-            model="gpt-5.6",
-            context_window_tokens=3_000,
-            context_block_limit=200,
-            max_tokens=1_000,
-            max_iterations=3,
-            max_tool_result_chars=10_000,
-            checkpoint_callback=checkpoint,
-        ))
+    await AgentRunner().run(make_run_spec(
+        provider,
+        initial_messages=[
+            {"role": "system", "content": "system"},
+            {"role": "user", "content": "read the file"},
+        ],
+        tools=tools,
+        model="gpt-5.6",
+        context_window_tokens=3_000,
+        context_block_limit=200,
+        max_tokens=1_000,
+        max_iterations=3,
+        max_tool_result_chars=10_000,
+        checkpoint_callback=checkpoint,
+    ))
 
-    assert calls == 1
+    assert captured_context is not None
+    assert captured_context.conversation_state is not None
+    pending = captured_context.conversation_state.pending_messages
+    assert len(pending) == 1
+    assert pending[0]["role"] == "tool"
+    assert "compacted to fit context" in pending[0]["content"]
+    assert pending[0]["content"] != "x" * 5_000
     completed_checkpoint = next(
         checkpoint
         for checkpoint in checkpoints
         if checkpoint["phase"] == "tools_completed"
     )
     checkpoint_pending = completed_checkpoint["provider_state"].pending_messages
-    assert checkpoint_pending == [{
-        "role": "tool",
-        "tool_call_id": "call_1",
-        "name": "read_file",
-        "content": "x" * 5_000,
-    }]
+    assert "compacted to fit context" in checkpoint_pending[0]["content"]
+    assert checkpoint_pending[0]["content"] != "x" * 5_000
 
 
 @pytest.mark.asyncio
@@ -832,6 +798,64 @@ async def test_runner_times_out_never_ending_streaming_request():
     provider.chat_with_retry.assert_not_awaited()
 
 
+@pytest.mark.asyncio
+async def test_runner_closes_progress_reasoning_on_streaming_wall_timeout():
+    from nanobot.agent.hook import AgentHook
+    from nanobot.agent.runner import AgentRunner
+
+    provider = MagicMock(spec=LLMProvider)
+    provider.supports_progress_deltas = True
+    events: list[tuple[str, str | None]] = []
+
+    async def chat_stream_with_retry(*, on_content_delta, **kwargs):
+        try:
+            await on_content_delta("<think>working...</think>")
+            await asyncio.sleep(3600)
+        finally:
+            events.append(("provider_cancelled", None))
+
+    provider.chat_stream_with_retry = chat_stream_with_retry
+    provider.chat_with_retry = AsyncMock()
+    tools = MagicMock()
+    tools.get_definitions.return_value = []
+
+    class ProgressReasoningHook(AgentHook):
+        async def emit_reasoning(self, reasoning_content: str | None) -> None:
+            if reasoning_content:
+                events.append(("reasoning", reasoning_content))
+
+        async def emit_reasoning_end(self) -> None:
+            events.append(("reasoning_end", None))
+
+    real_wait_for = asyncio.wait_for
+
+    async def fake_wait_for(coro, *, timeout):
+        assert timeout == 300.0
+        return await real_wait_for(coro, timeout=0.01)
+
+    runner = AgentRunner()
+    with patch("nanobot.agent.runner.asyncio.wait_for", fake_wait_for):
+        result = await runner.run(make_run_spec(provider,
+            initial_messages=[{"role": "user", "content": "think forever"}],
+            tools=tools,
+            model="test-model",
+            max_iterations=1,
+            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+            hook=ProgressReasoningHook(),
+            progress_callback=AsyncMock(),
+            llm_timeout_s=1,
+        ))
+
+    assert result.stop_reason == "error"
+    assert result.final_content == "Error calling LLM: timed out after 300s"
+    assert events == [
+        ("reasoning", "working..."),
+        ("provider_cancelled", None),
+        ("reasoning_end", None),
+    ]
+    provider.chat_with_retry.assert_not_awaited()
+
+
 @pytest.mark.asyncio
 async def test_runner_replaces_empty_tool_result_with_marker():
     from nanobot.agent.runner import AgentRunner
@@ -1261,8 +1285,13 @@ async def test_runner_accumulates_usage_and_preserves_cache_reads():
 
 
 @pytest.mark.asyncio
-async def test_runner_binds_on_retry_wait_callback():
-    """Provider retry heartbeats use the explicitly supplied callback."""
+async def test_runner_binds_on_retry_wait_to_retry_callback_not_progress():
+    """Regression: provider retry heartbeats must route through
+    ``retry_wait_callback``, not ``progress_callback``. Binding them to
+    the progress callback (as an earlier runtime refactor did) caused
+    internal retry diagnostics like "Model request failed, retry in 1s"
+    to leak to end-user channels as normal progress updates.
+    """
     from nanobot.agent.runner import AgentRunner
 
     captured: dict = {}
@@ -1276,6 +1305,7 @@ async def test_runner_binds_on_retry_wait_callback():
     tools = MagicMock()
     tools.get_definitions.return_value = []
 
+    progress_cb = AsyncMock()
     retry_wait_cb = AsyncMock()
 
     runner = AgentRunner()
@@ -1288,10 +1318,12 @@ async def test_runner_binds_on_retry_wait_callback():
         model="test-model",
         max_iterations=1,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
         retry_wait_callback=retry_wait_cb,
     ))
 
     assert captured["on_retry_wait"] is retry_wait_cb
+    assert captured["on_retry_wait"] is not progress_cb
 
 
 # ---------------------------------------------------------------------------

tests/agent/test_runner_errors.py

@@ -9,9 +9,7 @@ from unittest.mock import AsyncMock, MagicMock
 import pytest
 
 from agent.runner_helpers import make_run_spec
-from nanobot.agent.hook import AgentHook, AgentHookContext
 from nanobot.agent.tools import ToolResult
-from nanobot.agent.tools.execution import execute_tool_calls
 from nanobot.config.schema import AgentDefaults
 from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
 
@@ -52,36 +50,16 @@ async def test_runner_returns_tool_exception_to_model_for_recovery():
         {"name": "list_dir", "status": "error", "detail": "boom"}
     ]
     tool_message = next(message for message in result.messages if message.get("role") == "tool")
-    retry_hint = "[Analyze the error above and try a different approach.]"
     assert "Error: RuntimeError: boom" in tool_message["content"]
-    assert tool_message["content"].count(retry_hint) == 1
-
-
-@pytest.mark.asyncio
-async def test_tool_execution_does_not_duplicate_existing_retry_hint():
-    retry_hint = "\n\n[Analyze the error above and try a different approach.]"
-    tools = SimpleNamespace(
-        execute=AsyncMock(return_value=ToolResult.error("Error: boom" + retry_hint)),
-    )
-
-    results, events = await execute_tool_calls(
-        tools,
-        [ToolCallRequest(id="call_1", name="list_dir", arguments={})],
-        concurrent=False,
-        external_lookup_counts={},
-        workspace_violation_counts={},
-        hook=AgentHook(),
-        context=AgentHookContext(iteration=0, messages=[]),
-    )
-
-    assert results == ["Error: boom" + retry_hint]
-    assert results[0].count(retry_hint) == 1
-    assert events[0]["status"] == "error"
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("control_error", [KeyboardInterrupt, SystemExit])
-async def test_tool_execution_propagates_control_flow_exceptions(control_error: type[BaseException]):
+async def test_runner_propagates_tool_control_flow_exceptions(control_error: type[BaseException]):
+    from nanobot.agent.runner import AgentRunner
+
+    provider = MagicMock(spec=LLMProvider)
+
     async def execute(_name, _args):
         raise control_error("stop")
 
@@ -89,15 +67,22 @@ async def test_tool_execution_propagates_control_flow_exceptions(control_error:
         get_definitions=lambda: [],
         execute=execute,
     )
+    runner = AgentRunner()
+    spec = make_run_spec(
+        provider,
+        initial_messages=[],
+        tools=tools,
+        model="test-model",
+        max_iterations=1,
+        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+    )
+
     with pytest.raises(control_error):
-        await execute_tool_calls(
-            tools,
-            [ToolCallRequest(id="call_1", name="list_dir", arguments={})],
-            concurrent=False,
+        await runner._run_tool(
+            spec,
+            ToolCallRequest(id="call_1", name="list_dir", arguments={}),
             external_lookup_counts={},
             workspace_violation_counts={},
-            hook=AgentHook(),
-            context=AgentHookContext(iteration=0, messages=[]),
         )
 
 

tests/agent/test_runner_injections.py

@@ -10,7 +10,6 @@ import pytest
 
 from agent.runner_helpers import make_run_spec
 from nanobot.agent.automation_turns import publish_next_deferred_turn
-from nanobot.agent.context import TranscriptInput
 from nanobot.agent.tools.context import RequestContext
 from nanobot.config.schema import AgentDefaults
 from nanobot.providers.base import LLMResponse, ToolCallRequest
@@ -618,7 +617,7 @@ async def test_loop_injected_followup_preserves_image_media(tmp_path):
 
     runtime = loop.llm_runtime()
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "hello"}], current_message=None),
+        [{"role": "user", "content": "hello"}],
         runtime=runtime,
         request_context=RequestContext(channel="cli", chat_id="c", runtime=runtime),
         pending_queue=pending_queue,
@@ -712,10 +711,7 @@ async def test_pending_injection_resolves_its_own_runtime_context(tmp_path):
 
     runtime = loop.llm_runtime()
     result = await loop._run_agent_loop(
-        TranscriptInput(
-            history=[{"role": "user", "content": "initial message from user A"}],
-            current_message=None,
-        ),
+        [{"role": "user", "content": "initial message from user A"}],
         runtime=runtime,
         session=session,
         request_context=RequestContext(
@@ -750,27 +746,25 @@ async def test_pending_injection_resolves_its_own_runtime_context(tmp_path):
         ),
     ]
 
-    injected = [message for message in result.messages if message.get("role") == "user"][-2:]
-    assert str(injected[0]["content"]).startswith("follow-up from the second speaker\n\n")
-    assert str(injected[1]["content"]).startswith("another follow-up\n\n")
+    injected = [message for message in result.messages if message.get("role") == "user"][-1]
+    assert "follow-up from the second speaker" in str(injected["content"])
     model_messages = provider.chat_with_retry.await_args_list[-1].kwargs["messages"]
     assert "telegram | group-1 | user-b | message-2" in str(model_messages)
     assert "Bob | topic-7" in str(model_messages)
     assert "telegram | group-1 | user-c | message-3" in str(model_messages)
     assert "Carol | topic-7" in str(model_messages)
-    assert all(
-        message["_meta"][RUNTIME_CONTEXT_MESSAGE_META]["sources"] == ["identity"]
-        for message in injected
-    )
+    assert injected["_meta"][RUNTIME_CONTEXT_MESSAGE_META]["sources"] == [
+        "identity",
+        "identity",
+    ]
 
     loop._save_turn(session, result.messages, skip=1)
-    persisted = [message for message in session.messages if message.get("role") == "user"][-2:]
-    assert "telegram | group-1 | user-b | message-2" in str(persisted[0]["content"])
-    assert "telegram | group-1 | user-c | message-3" in str(persisted[1]["content"])
-    assert [public_history_message(message)["content"] for message in persisted] == [
-        "follow-up from the second speaker",
-        "another follow-up",
-    ]
+    persisted = [message for message in session.messages if message.get("role") == "user"][-1]
+    assert "telegram | group-1 | user-b | message-2" in str(persisted["content"])
+    assert "telegram | group-1 | user-c | message-3" in str(persisted["content"])
+    assert public_history_message(persisted)["content"] == (
+        "follow-up from the second speaker\n\nanother follow-up"
+    )
 
 
 @pytest.mark.asyncio
@@ -818,7 +812,7 @@ async def test_subagent_pending_injection_is_hidden_history_and_not_merged(tmp_p
 
     runtime = loop.llm_runtime()
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "hello"}], current_message=None),
+        [{"role": "user", "content": "hello"}],
         runtime=runtime,
         request_context=RequestContext(channel="cli", chat_id="c", runtime=runtime),
         pending_queue=pending_queue,
@@ -837,8 +831,8 @@ async def test_subagent_pending_injection_is_hidden_history_and_not_merged(tmp_p
 
 
 @pytest.mark.asyncio
-async def test_model_request_merges_injected_user_messages_without_losing_media():
-    """The model copy may merge follow-ups while the raw transcript keeps each event."""
+async def test_runner_merges_multiple_injected_user_messages_without_losing_media():
+    """Multiple injected follow-ups should not create lossy consecutive user messages."""
     from nanobot.agent.runner import AgentRunner
 
     provider = MagicMock()
@@ -897,17 +891,10 @@ async def test_model_request_merges_injected_user_messages_without_losing_media(
         for block in injected["content"]
         if isinstance(block, dict)
     )
-    assert [message["content"] for message in result.messages[-3:-1]] == [
-        [
-            {"type": "image_url", "image_url": {"url": "data:image/png;base64,abc"}},
-            {"type": "text", "text": "look at this"},
-        ],
-        "and answer briefly",
-    ]
 
 
-def test_runner_append_keeps_recovery_followups_separate() -> None:
-    """Each raw follow-up keeps its own recovery identity."""
+def test_runner_merge_keeps_all_recovery_followup_ids() -> None:
+    """Merged follow-ups stay acknowledged together after a later save."""
     from nanobot.agent.runner import AgentRunner
     from nanobot.session.recovery import PENDING_FOLLOWUP_ID_KEY
 
@@ -917,12 +904,10 @@ def test_runner_append_keeps_recovery_followups_separate() -> None:
         [{"role": "user", "content": "second", PENDING_FOLLOWUP_ID_KEY: "two"}],
     )
 
-    assert [message["content"] for message in messages] == ["first", "second"]
-    assert [message[PENDING_FOLLOWUP_ID_KEY] for message in messages] == ["one", "two"]
+    assert messages[-1][PENDING_FOLLOWUP_ID_KEY] == ["one", "two"]
 
 
-def test_model_request_merge_preserves_runtime_markers_with_media() -> None:
-    from nanobot.agent.context_governance import ContextGovernor
+def test_runner_merge_preserves_runtime_markers_with_media() -> None:
     from nanobot.agent.runner import AgentRunner
     from nanobot.runtime_context import (
         RUNTIME_CONTEXT_HISTORY_META,
@@ -959,9 +944,8 @@ def test_model_request_merge_preserves_runtime_markers_with_media() -> None:
         },
     ])
 
-    assert len(messages) == 2
-    merged = ContextGovernor._merge_adjacent_user_messages_for_model(messages)[0]
-    assert len(messages) == 2
+    assert len(messages) == 1
+    merged = messages[0]
     assert "private first" in str(merged["content"])
     assert "private second" in str(merged["content"])
     persisted = {
@@ -1492,7 +1476,7 @@ async def test_pending_queue_preserves_overflow_for_next_injection_cycle(tmp_pat
 
     runtime = loop.llm_runtime()
     result = await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "hello"}], current_message=None),
+        [{"role": "user", "content": "hello"}],
         runtime=runtime,
         request_context=RequestContext(channel="cli", chat_id="c", runtime=runtime),
         pending_queue=pending_queue,
@@ -1693,17 +1677,15 @@ async def test_drain_injections_after_recoverable_tool_error():
 
 @pytest.mark.asyncio
 async def test_drain_injections_on_llm_error():
-    """A follow-up after an error stays raw and reaches the next model request."""
+    """Pending injections should be drained when the LLM returns an error finish_reason."""
     from nanobot.agent.runner import AgentRunner
     from nanobot.bus.events import InboundMessage
 
     provider = MagicMock()
     call_count = {"n": 0}
-    requests: list[list[dict]] = []
 
     async def chat_with_retry(*, messages, **kwargs):
         call_count["n"] += 1
-        requests.append(messages)
         if call_count["n"] == 1:
             return LLMResponse(
                 content=None,
@@ -1727,20 +1709,11 @@ async def test_drain_injections_on_llm_error():
 
     runner = AgentRunner()
     result = await runner.run(make_run_spec(provider,
-        initial_messages=None,
-        transcript_input=TranscriptInput(
-            history=[
-                {"role": "user", "content": "hello"},
-                {"role": "assistant", "content": "previous response"},
-                {"role": "user", "content": "trigger error"},
-            ],
-            current_message=None,
-        ),
-        transcript_builder=lambda transcript: [
-            {"role": "system", "content": "system"},
-            *transcript.history,
+        initial_messages=[
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": "previous response"},
+            {"role": "user", "content": "trigger error"},
         ],
-        consolidate_history=AsyncMock(return_value=None),
         tools=tools,
         model="test-model",
         max_iterations=5,
@@ -1750,15 +1723,11 @@ async def test_drain_injections_on_llm_error():
 
     assert result.had_injections is True
     assert result.final_content == "recovered answer"
-    assert "follow-up after LLM error" in str(requests[1])
-    assert [
-        message["content"]
-        for message in result.messages
-        if message.get("role") == "user"
-    ][-2:] == [
-        "trigger error",
-        "follow-up after LLM error",
+    injected = [
+        m for m in result.messages
+        if m.get("role") == "user" and "follow-up after LLM error" in str(m.get("content", ""))
     ]
+    assert len(injected) == 1
 
 
 @pytest.mark.asyncio

tests/agent/test_runner_progress_deltas.py

@@ -1,4 +1,4 @@
-"""Tests for runner progress hooks and provider event routing."""
+"""Tests for provider progress delta routing in the shared runner."""
 
 import asyncio
 from unittest.mock import AsyncMock, MagicMock
@@ -6,6 +6,7 @@ from unittest.mock import AsyncMock, MagicMock
 import pytest
 
 from agent.runner_helpers import make_run_spec
+from nanobot.agent.hook import CompositeHook
 from nanobot.agent.hooks import FileEditActivityHook
 from nanobot.agent.progress_hook import AgentProgressHook
 from nanobot.agent.runner import AgentRunner
@@ -16,9 +17,45 @@ from nanobot.providers.base import LLMResponse, ToolCallRequest
 _MAX_TOOL_RESULT_CHARS = AgentDefaults().max_tool_result_chars
 
 
+@pytest.mark.asyncio
+async def test_runner_streams_provider_progress_deltas_by_default():
+    """Direct runner users keep the existing opt-in provider progress behavior."""
+    provider = MagicMock()
+    provider.supports_progress_deltas = True
+
+    async def chat_stream_with_retry(*, on_content_delta, **kwargs):
+        await on_content_delta("he")
+        await on_content_delta("llo")
+        return LLMResponse(content="hello", tool_calls=[], usage=None)
+
+    provider.chat_stream_with_retry = chat_stream_with_retry
+    provider.chat_with_retry = AsyncMock()
+    tools = MagicMock()
+    tools.get_definitions.return_value = []
+    progress_cb = AsyncMock()
+
+    runner = AgentRunner()
+    result = await runner.run(make_run_spec(provider,
+        initial_messages=[
+            {"role": "system", "content": "system"},
+            {"role": "user", "content": "hi"},
+        ],
+        tools=tools,
+        model="test-model",
+        max_iterations=1,
+        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
+    ))
+
+    assert result.final_content == "hello"
+    assert [call.args[0] for call in progress_cb.await_args_list] == ["he", "llo"]
+    provider.chat_with_retry.assert_not_awaited()
+
+
 @pytest.mark.asyncio
 async def test_runner_routes_hosted_tool_events_to_structured_progress():
     provider = MagicMock()
+    provider.supports_progress_deltas = True
 
     async def chat_stream_with_retry(*, on_content_delta, on_tool_call_delta, **kwargs):
         await on_tool_call_delta({
@@ -51,17 +88,13 @@ async def test_runner_routes_hosted_tool_events_to_structured_progress():
     tools.get_definitions.return_value = []
     progress_events: list[dict] = []
     progress_text: list[str] = []
-    streamed_text: list[str] = []
 
     async def progress_cb(content, *, tool_events=None, **kwargs):
         progress_text.append(content)
         if tool_events:
             progress_events.extend(tool_events)
 
-    async def stream_cb(content: str) -> None:
-        streamed_text.append(content)
-
-    hook = AgentProgressHook(on_progress=progress_cb, on_stream=stream_cb)
+    hook = CompositeHook([AgentProgressHook(on_progress=progress_cb)])
     result = await AgentRunner().run(make_run_spec(
         provider,
         initial_messages=[{"role": "user", "content": "search X"}],
@@ -69,6 +102,7 @@ async def test_runner_routes_hosted_tool_events_to_structured_progress():
         model="test-model",
         max_iterations=1,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
         hook=hook,
     ))
 
@@ -99,14 +133,14 @@ async def test_runner_routes_hosted_tool_events_to_structured_progress():
             "embeds": [],
         },
     ]
-    assert progress_text == ['search X "nanobot oauth"', ""]
-    assert streamed_text == ["done"]
+    assert progress_text == ['search X "nanobot oauth"', "", "done"]
     provider.chat_with_retry.assert_not_awaited()
 
 
 @pytest.mark.asyncio
 async def test_runner_fails_pending_hosted_tool_when_model_request_fails():
     provider = MagicMock()
+    provider.supports_progress_deltas = True
 
     async def chat_stream_with_retry(*, on_tool_call_delta, **kwargs):
         await on_tool_call_delta({
@@ -132,10 +166,7 @@ async def test_runner_fails_pending_hosted_tool_when_model_request_fails():
         if tool_events:
             progress_events.extend(tool_events)
 
-    async def stream_cb(_content: str) -> None:
-        pass
-
-    hook = AgentProgressHook(on_progress=progress_cb, on_stream=stream_cb)
+    hook = CompositeHook([AgentProgressHook(on_progress=progress_cb)])
     result = await AgentRunner().run(make_run_spec(
         provider,
         initial_messages=[{"role": "user", "content": "search X"}],
@@ -143,6 +174,7 @@ async def test_runner_fails_pending_hosted_tool_when_model_request_fails():
         model="test-model",
         max_iterations=1,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
         hook=hook,
     ))
 
@@ -168,6 +200,7 @@ async def test_runner_fails_pending_hosted_tool_when_model_request_fails():
 @pytest.mark.asyncio
 async def test_runner_emits_write_file_diff_from_tool_execution_snapshots(tmp_path):
     provider = MagicMock()
+    provider.supports_progress_deltas = True
     call_count = 0
     progress_events: list[dict] = []
     (tmp_path / "big.txt").write_text("old\n", encoding="utf-8")
@@ -185,7 +218,7 @@ async def test_runner_emits_write_file_diff_from_tool_execution_snapshots(tmp_pa
         def prepare_call(self, name, params):
             return tool, params, None
 
-    async def chat_with_retry(**kwargs):
+    async def chat_stream_with_retry(**kwargs):
         nonlocal call_count
         call_count += 1
         if call_count == 1:
@@ -202,7 +235,8 @@ async def test_runner_emits_write_file_diff_from_tool_execution_snapshots(tmp_pa
             )
         return LLMResponse(content="done", tool_calls=[], usage=None)
 
-    provider.chat_with_retry = chat_with_retry
+    provider.chat_stream_with_retry = chat_stream_with_retry
+    provider.chat_with_retry = AsyncMock()
     tools = Tools()
 
     runner = AgentRunner()
@@ -212,6 +246,7 @@ async def test_runner_emits_write_file_diff_from_tool_execution_snapshots(tmp_pa
         model="test-model",
         max_iterations=2,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
         workspace=tmp_path,
         hook=FileEditActivityHook(on_progress=progress_cb, workspace=tmp_path),
     ))
@@ -228,11 +263,13 @@ async def test_runner_emits_write_file_diff_from_tool_execution_snapshots(tmp_pa
         and event["diff"]["format"] == "unified"
         for event in progress_events
     )
+    provider.chat_with_retry.assert_not_awaited()
 
 
 @pytest.mark.asyncio
 async def test_runner_emits_edit_file_diff_from_tool_execution_snapshots(tmp_path):
     provider = MagicMock()
+    provider.supports_progress_deltas = True
     call_count = 0
     progress_events: list[dict] = []
     target = tmp_path / "notes.txt"
@@ -251,7 +288,7 @@ async def test_runner_emits_edit_file_diff_from_tool_execution_snapshots(tmp_pat
         def prepare_call(self, name, params):
             return tool, params, None
 
-    async def chat_with_retry(**kwargs):
+    async def chat_stream_with_retry(**kwargs):
         nonlocal call_count
         call_count += 1
         if call_count == 1:
@@ -272,7 +309,8 @@ async def test_runner_emits_edit_file_diff_from_tool_execution_snapshots(tmp_pat
             )
         return LLMResponse(content="done", tool_calls=[], usage=None)
 
-    provider.chat_with_retry = chat_with_retry
+    provider.chat_stream_with_retry = chat_stream_with_retry
+    provider.chat_with_retry = AsyncMock()
     tools = Tools()
 
     runner = AgentRunner()
@@ -282,6 +320,7 @@ async def test_runner_emits_edit_file_diff_from_tool_execution_snapshots(tmp_pat
         model="test-model",
         max_iterations=2,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
         workspace=tmp_path,
         hook=FileEditActivityHook(on_progress=progress_cb, workspace=tmp_path),
     ))
@@ -296,11 +335,13 @@ async def test_runner_emits_edit_file_diff_from_tool_execution_snapshots(tmp_pat
         and event["diff"]["format"] == "unified"
         for event in progress_events
     )
+    provider.chat_with_retry.assert_not_awaited()
 
 
 @pytest.mark.asyncio
 async def test_runner_marks_file_edit_activity_failed_when_tool_errors(tmp_path):
     provider = MagicMock()
+    provider.supports_progress_deltas = True
     call_count = 0
     progress_events: list[dict] = []
 
@@ -317,7 +358,7 @@ async def test_runner_marks_file_edit_activity_failed_when_tool_errors(tmp_path)
         def prepare_call(self, name, params):
             return tool, params, None
 
-    async def chat_with_retry(**kwargs):
+    async def chat_stream_with_retry(**kwargs):
         nonlocal call_count
         call_count += 1
         if call_count == 1:
@@ -334,7 +375,8 @@ async def test_runner_marks_file_edit_activity_failed_when_tool_errors(tmp_path)
             )
         return LLMResponse(content="done", tool_calls=[], usage=None)
 
-    provider.chat_with_retry = chat_with_retry
+    provider.chat_stream_with_retry = chat_stream_with_retry
+    provider.chat_with_retry = AsyncMock()
     tools = Tools()
 
     runner = AgentRunner()
@@ -344,6 +386,7 @@ async def test_runner_marks_file_edit_activity_failed_when_tool_errors(tmp_path)
         model="test-model",
         max_iterations=2,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
         workspace=tmp_path,
         hook=FileEditActivityHook(on_progress=progress_cb, workspace=tmp_path),
     ))
@@ -352,11 +395,13 @@ async def test_runner_marks_file_edit_activity_failed_when_tool_errors(tmp_path)
     assert progress_events[-1]["path"] == "aborted.txt"
     assert progress_events[-1]["phase"] == "error"
     assert progress_events[-1]["status"] == "error"
+    provider.chat_with_retry.assert_not_awaited()
 
 
 @pytest.mark.asyncio
 async def test_runner_marks_file_edit_activity_failed_when_cancelled(tmp_path):
     provider = MagicMock()
+    provider.supports_progress_deltas = True
     progress_events: list[dict] = []
     executing = asyncio.Event()
     target = tmp_path / "cancelled.txt"
@@ -381,7 +426,7 @@ async def test_runner_marks_file_edit_activity_failed_when_cancelled(tmp_path):
         def prepare_call(self, name, params):
             return tool, params, None
 
-    async def chat_with_retry(**kwargs):
+    async def chat_stream_with_retry(**kwargs):
         return LLMResponse(
             content=None,
             tool_calls=[
@@ -394,7 +439,8 @@ async def test_runner_marks_file_edit_activity_failed_when_cancelled(tmp_path):
             usage=None,
         )
 
-    provider.chat_with_retry = chat_with_retry
+    provider.chat_stream_with_retry = chat_stream_with_retry
+    provider.chat_with_retry = AsyncMock()
     tools = Tools()
 
     runner = AgentRunner()
@@ -404,6 +450,7 @@ async def test_runner_marks_file_edit_activity_failed_when_cancelled(tmp_path):
         model="test-model",
         max_iterations=2,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+        progress_callback=progress_cb,
         workspace=tmp_path,
         hook=FileEditActivityHook(on_progress=progress_cb, workspace=tmp_path),
     )))
@@ -417,3 +464,4 @@ async def test_runner_marks_file_edit_activity_failed_when_cancelled(tmp_path):
     assert progress_events[-1]["path"] == "cancelled.txt"
     assert progress_events[-1]["status"] == "error"
     assert progress_events[-1]["error"] == "Task interrupted before this tool finished."
+    provider.chat_with_retry.assert_not_awaited()

tests/agent/test_runner_reasoning.py

@@ -9,15 +9,12 @@ channels, gated by ``context.streamed_reasoning`` rather than
 
 from __future__ import annotations
 
-import asyncio
-from typing import Any
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
 from agent.runner_helpers import make_run_spec
 from nanobot.agent.hook import AgentHook, AgentHookContext
-from nanobot.agent.progress_hook import AgentProgressHook
 from nanobot.config.schema import AgentDefaults
 from nanobot.providers.base import LLMResponse, LLMUsage, ToolCallRequest
 
@@ -38,63 +35,6 @@ class _RecordingHook(AgentHook):
         self.end_calls += 1
 
 
-class _StreamRecordingHook(_RecordingHook):
-    def __init__(self) -> None:
-        super().__init__()
-        self.streamed: list[str] = []
-
-    def wants_streaming(self) -> bool:
-        return True
-
-    async def on_stream(self, _ctx: AgentHookContext, delta: str) -> None:
-        self.streamed.append(delta)
-
-
-class _LifecycleRecordingHook(AgentHook):
-    def __init__(self) -> None:
-        super().__init__()
-        self.events: list[str] = []
-
-    def wants_streaming(self) -> bool:
-        return True
-
-    async def emit_reasoning(self, reasoning_content: str | None) -> None:
-        if reasoning_content:
-            self.events.append(f"reasoning:{reasoning_content}")
-
-    async def emit_reasoning_end(self) -> None:
-        self.events.append("reasoning_end")
-
-    async def on_stream(self, _ctx: AgentHookContext, delta: str) -> None:
-        self.events.append(f"content:{delta}")
-
-    async def on_stream_end(self, _ctx: AgentHookContext, *, resuming: bool) -> None:
-        self.events.append(f"stream_end:{resuming}")
-
-    async def before_execute_tools(self, context: AgentHookContext) -> None:
-        names = ",".join(call.name for call in context.tool_calls)
-        self.events.append(f"local_tools:{names}")
-
-    async def on_provider_tool_event(
-        self,
-        _context: AgentHookContext,
-        event: dict[str, Any],
-    ) -> None:
-        self.events.append(f"hosted_tool:{event.get('phase')}")
-
-
-class _BlockingReasoningEndHook(_LifecycleRecordingHook):
-    def __init__(self) -> None:
-        super().__init__()
-        self.reasoning_end_started = asyncio.Event()
-        self.release_reasoning_end = asyncio.Event()
-
-    async def emit_reasoning_end(self) -> None:
-        self.reasoning_end_started.set()
-        await self.release_reasoning_end.wait()
-        await super().emit_reasoning_end()
-
-
 @pytest.mark.asyncio
 async def test_runner_preserves_reasoning_fields_in_assistant_history():
     """Reasoning fields ride along on the persisted assistant message so
@@ -261,6 +201,7 @@ async def test_runner_emits_reasoning_content_even_when_answer_was_streamed():
     from nanobot.agent.runner import AgentRunner
 
     provider = MagicMock()
+    provider.supports_progress_deltas = True
 
     async def chat_stream_with_retry(*, on_content_delta=None, **kwargs):
         if on_content_delta:
@@ -277,7 +218,12 @@ async def test_runner_emits_reasoning_content_even_when_answer_was_streamed():
     tools = MagicMock()
     tools.get_definitions.return_value = []
 
-    hook = _StreamRecordingHook()
+    progress_calls: list[str] = []
+
+    async def _progress(content: str, **_kwargs):
+        progress_calls.append(content)
+
+    hook = _RecordingHook()
     runner = AgentRunner()
     result = await runner.run(make_run_spec(provider,
         initial_messages=[{"role": "user", "content": "question"}],
@@ -286,10 +232,11 @@ async def test_runner_emits_reasoning_content_even_when_answer_was_streamed():
         max_iterations=3,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
         hook=hook,
+        progress_callback=_progress,
     ))
 
     assert result.final_content == "The answer."
-    assert hook.streamed == ["The ", "answer."]
+    assert progress_calls, "answer should have streamed via progress callback"
     assert hook.emitted == ["step-by-step deduction"]
 
 
@@ -300,6 +247,7 @@ async def test_runner_does_not_double_emit_when_inline_think_already_streamed():
     from nanobot.agent.runner import AgentRunner
 
     provider = MagicMock()
+    provider.supports_progress_deltas = True
 
     async def chat_stream_with_retry(*, on_content_delta=None, **kwargs):
         if on_content_delta:
@@ -315,16 +263,10 @@ async def test_runner_does_not_double_emit_when_inline_think_already_streamed():
     tools = MagicMock()
     tools.get_definitions.return_value = []
 
-    reasoning_events: list[str] = []
-
-    async def _progress(content: str, *, reasoning: bool = False, **_kwargs):
-        if reasoning:
-            reasoning_events.append(content)
-
-    async def _stream(_content: str) -> None:
+    async def _progress(content: str, **_kwargs):
         pass
 
-    hook = AgentProgressHook(on_progress=_progress, on_stream=_stream)
+    hook = _RecordingHook()
     runner = AgentRunner()
     result = await runner.run(make_run_spec(provider,
         initial_messages=[{"role": "user", "content": "question"}],
@@ -333,10 +275,12 @@ async def test_runner_does_not_double_emit_when_inline_think_already_streamed():
         max_iterations=3,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
         hook=hook,
+        progress_callback=_progress,
     ))
 
     assert result.final_content == "The answer."
-    assert reasoning_events == ["working..."]
+    assert hook.emitted == ["working..."]
+    assert hook.end_calls >= 1, "reasoning stream must be closed once the answer starts"
 
 
 @pytest.mark.asyncio
@@ -376,6 +320,14 @@ async def test_runner_closes_reasoning_stream_after_one_shot_response():
     assert hook.end_calls == 1
 
 
+class _StreamRecordingHook(_RecordingHook):
+    def wants_streaming(self) -> bool:
+        return True
+
+    async def on_stream(self, _ctx: AgentHookContext, delta: str) -> None:
+        pass
+
+
 @pytest.mark.asyncio
 async def test_runner_streams_native_thinking_deltas_without_post_hoc_dup():
     """Anthropic-style ``on_thinking_delta`` should fan out to ``emit_reasoning``;
@@ -418,235 +370,6 @@ async def test_runner_streams_native_thinking_deltas_without_post_hoc_dup():
     assert hook.emitted == ["part1", "part2"]
 
 
-@pytest.mark.asyncio
-async def test_runner_closes_native_reasoning_before_streaming_answer():
-    from nanobot.agent.runner import AgentRunner
-
-    provider = MagicMock()
-
-    async def chat_stream_with_retry(
-        *, on_content_delta=None, on_thinking_delta=None, **kwargs
-    ):
-        if on_thinking_delta:
-            await on_thinking_delta("inspect")
-        if on_content_delta:
-            await on_content_delta("done")
-        return LLMResponse(content="done", tool_calls=[], usage=None)
-
-    provider.chat_stream_with_retry = chat_stream_with_retry
-    tools = MagicMock()
-    tools.get_definitions.return_value = []
-    hook = _LifecycleRecordingHook()
-
-    result = await AgentRunner().run(make_run_spec(
-        provider,
-        initial_messages=[{"role": "user", "content": "q"}],
-        tools=tools,
-        model="test-model",
-        max_iterations=1,
-        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-        hook=hook,
-    ))
-
-    assert result.final_content == "done"
-    assert hook.events == [
-        "reasoning:inspect",
-        "reasoning_end",
-        "content:done",
-        "stream_end:False",
-    ]
-
-
-@pytest.mark.asyncio
-async def test_runner_closes_native_reasoning_before_local_tool_execution():
-    from nanobot.agent.runner import AgentRunner
-
-    provider = MagicMock()
-    responses = iter([
-        LLMResponse(
-            content="",
-            finish_reason="tool_calls",
-            tool_calls=[ToolCallRequest(id="call-1", name="list_dir", arguments={"path": "."})],
-            usage=None,
-        ),
-        LLMResponse(content="done", tool_calls=[], usage=None),
-    ])
-
-    async def chat_stream_with_retry(
-        *, on_content_delta=None, on_thinking_delta=None, **kwargs
-    ):
-        response = next(responses)
-        if response.tool_calls:
-            if on_thinking_delta:
-                await on_thinking_delta("inspect")
-        elif on_content_delta:
-            await on_content_delta("done")
-        return response
-
-    provider.chat_stream_with_retry = chat_stream_with_retry
-    tools = MagicMock()
-    tools.get_definitions.return_value = []
-    tools.execute = AsyncMock(return_value="tool result")
-    hook = _LifecycleRecordingHook()
-
-    result = await AgentRunner().run(make_run_spec(
-        provider,
-        initial_messages=[{"role": "user", "content": "inspect"}],
-        tools=tools,
-        model="test-model",
-        max_iterations=2,
-        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-        hook=hook,
-    ))
-
-    assert result.final_content == "done"
-    assert hook.events == [
-        "reasoning:inspect",
-        "reasoning_end",
-        "stream_end:True",
-        "local_tools:list_dir",
-        "content:done",
-        "stream_end:False",
-    ]
-
-
-@pytest.mark.asyncio
-async def test_runner_closes_native_reasoning_before_hosted_tool_event():
-    from nanobot.agent.runner import AgentRunner
-
-    provider = MagicMock()
-
-    async def chat_stream_with_retry(
-        *, on_content_delta=None, on_thinking_delta=None, on_tool_call_delta=None, **kwargs
-    ):
-        if on_thinking_delta:
-            await on_thinking_delta("search")
-        if on_tool_call_delta:
-            await on_tool_call_delta({
-                "kind": "hosted_tool",
-                "phase": "start",
-                "call_id": "search-1",
-                "name": "web_search",
-                "arguments": {"query": "nanobot"},
-            })
-            await on_tool_call_delta({
-                "kind": "hosted_tool",
-                "phase": "end",
-                "call_id": "search-1",
-                "name": "web_search",
-                "arguments": {"query": "nanobot"},
-                "result": {"count": 1},
-            })
-        if on_content_delta:
-            await on_content_delta("done")
-        return LLMResponse(content="done", tool_calls=[], usage=None)
-
-    provider.chat_stream_with_retry = chat_stream_with_retry
-    tools = MagicMock()
-    tools.get_definitions.return_value = []
-    hook = _LifecycleRecordingHook()
-
-    result = await AgentRunner().run(make_run_spec(
-        provider,
-        initial_messages=[{"role": "user", "content": "search"}],
-        tools=tools,
-        model="test-model",
-        max_iterations=1,
-        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-        hook=hook,
-    ))
-
-    assert result.final_content == "done"
-    assert hook.events == [
-        "reasoning:search",
-        "reasoning_end",
-        "hosted_tool:start",
-        "hosted_tool:end",
-        "content:done",
-        "stream_end:False",
-    ]
-
-
-@pytest.mark.asyncio
-async def test_runner_closes_native_reasoning_when_stream_is_cancelled():
-    from nanobot.agent.runner import AgentRunner
-
-    provider = MagicMock()
-    reasoning_started = asyncio.Event()
-    release_provider = asyncio.Event()
-
-    async def chat_stream_with_retry(
-        *, on_thinking_delta=None, **kwargs
-    ):
-        if on_thinking_delta:
-            await on_thinking_delta("inspect")
-        reasoning_started.set()
-        await release_provider.wait()
-        raise AssertionError("the cancelled provider call should not complete")
-
-    provider.chat_stream_with_retry = chat_stream_with_retry
-    tools = MagicMock()
-    tools.get_definitions.return_value = []
-    hook = _LifecycleRecordingHook()
-
-    task = asyncio.create_task(AgentRunner().run(make_run_spec(
-        provider,
-        initial_messages=[{"role": "user", "content": "inspect"}],
-        tools=tools,
-        model="test-model",
-        max_iterations=1,
-        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-        hook=hook,
-    )))
-    await reasoning_started.wait()
-
-    task.cancel()
-    with pytest.raises(asyncio.CancelledError):
-        await task
-
-    assert hook.events == ["reasoning:inspect", "reasoning_end"]
-
-
-@pytest.mark.asyncio
-async def test_runner_settles_native_reasoning_end_before_propagating_cancellation():
-    from nanobot.agent.runner import AgentRunner
-
-    provider = MagicMock()
-
-    async def chat_stream_with_retry(
-        *, on_content_delta=None, on_thinking_delta=None, **kwargs
-    ):
-        if on_thinking_delta:
-            await on_thinking_delta("inspect")
-        if on_content_delta:
-            await on_content_delta("done")
-        raise AssertionError("the cancelled provider call should not complete")
-
-    provider.chat_stream_with_retry = chat_stream_with_retry
-    tools = MagicMock()
-    tools.get_definitions.return_value = []
-    hook = _BlockingReasoningEndHook()
-
-    task = asyncio.create_task(AgentRunner().run(make_run_spec(
-        provider,
-        initial_messages=[{"role": "user", "content": "inspect"}],
-        tools=tools,
-        model="test-model",
-        max_iterations=1,
-        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-        hook=hook,
-    )))
-    await hook.reasoning_end_started.wait()
-
-    task.cancel()
-    await asyncio.sleep(0)
-    hook.release_reasoning_end.set()
-    with pytest.raises(asyncio.CancelledError):
-        await task
-
-    assert hook.events == ["reasoning:inspect", "reasoning_end"]
-
-
 @pytest.mark.asyncio
 async def test_runner_strips_thinking_tags_from_native_thinking_deltas():
     from nanobot.agent.runner import AgentRunner

tests/agent/test_runner_safety.py

@@ -9,7 +9,6 @@ import pytest
 from agent.runner_helpers import make_run_spec
 from nanobot.agent.runner import AgentRunner
 from nanobot.agent.tools import ToolResult
-from nanobot.agent.tools.execution import is_ssrf_violation
 from nanobot.config.schema import AgentDefaults
 from nanobot.providers.base import LLMResponse, ToolCallRequest
 
@@ -67,20 +66,20 @@ async def test_runner_does_not_abort_on_workspace_violation_anymore():
 def test_is_ssrf_violation_recognizes_private_url_blocks():
     """SSRF rejections are classified separately from workspace boundaries."""
     ssrf_msg = "Error: Command blocked by safety guard (internal/private URL detected)"
-    assert is_ssrf_violation(ssrf_msg) is True
-    assert is_ssrf_violation(
+    assert AgentRunner._is_ssrf_violation(ssrf_msg) is True
+    assert AgentRunner._is_ssrf_violation(
         "URL validation failed: Blocked: host resolves to private/internal address 192.168.1.2"
     ) is True
 
     # Workspace-bound markers are NOT classified as SSRF.
-    assert is_ssrf_violation(
+    assert AgentRunner._is_ssrf_violation(
         "Error: Command blocked by safety guard (path outside working dir)"
     ) is False
-    assert is_ssrf_violation(
+    assert AgentRunner._is_ssrf_violation(
         "Path /tmp/x is outside allowed directory /ws"
     ) is False
     # Deny / allowlist filter messages stay non-fatal too.
-    assert is_ssrf_violation(
+    assert AgentRunner._is_ssrf_violation(
         "Error: Command blocked by deny pattern filter"
     ) is False
 

tests/agent/test_runner_tool_execution.py

@@ -3,17 +3,14 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
 from agent.runner_helpers import make_run_spec
-from nanobot.agent.hook import AgentHook, AgentHookContext
 from nanobot.agent.runner import AgentRunner
 from nanobot.agent.tools.base import Tool, ToolResult
 from nanobot.agent.tools.context import ToolContext
-from nanobot.agent.tools.execution import execute_tool_calls
 from nanobot.agent.tools.loader import ToolLoader
 from nanobot.agent.tools.registry import ToolRegistry
 from nanobot.config.schema import AgentDefaults
@@ -153,69 +150,31 @@ def _tool_message(result, tool_call_id: str) -> dict:
 
 
 @pytest.mark.asyncio
-async def test_tool_execution_propagates_preparation_failure():
+async def test_runner_propagates_tool_preparation_failure():
     tools = MagicMock()
     tools.prepare_call.side_effect = RuntimeError("tool preparation failed")
     tools.execute = AsyncMock()
 
     with pytest.raises(RuntimeError, match="tool preparation failed"):
-        await execute_tool_calls(
-            tools,
-            [ToolCallRequest(id="call-1", name="demo", arguments={})],
-            concurrent=False,
-            external_lookup_counts={},
-            workspace_violation_counts={},
-            hook=AgentHook(),
-            context=AgentHookContext(iteration=0, messages=[]),
+        await AgentRunner()._run_tool(
+            make_run_spec(
+                MagicMock(),
+                initial_messages=[],
+                tools=tools,
+                model="test-model",
+                max_iterations=1,
+                max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+            ),
+            ToolCallRequest(id="call-1", name="demo", arguments={}),
+            {},
+            {},
         )
 
     tools.execute.assert_not_awaited()
 
 
 @pytest.mark.asyncio
-async def test_tool_execution_propagates_cancellation_without_error_hook():
-    tools = MagicMock()
-    tools.prepare_call.return_value = (None, {}, None)
-    tools.execute = AsyncMock(side_effect=asyncio.CancelledError)
-
-    events: list[str] = []
-
-    class RecordingHook(AgentHook):
-        async def before_execute_tool(
-            self,
-            context: AgentHookContext,
-            tool_call: ToolCallRequest,
-            tool: Any,
-            params: Any,
-        ) -> None:
-            events.append("before")
-
-        async def on_execute_tool_error(
-            self,
-            context: AgentHookContext,
-            tool_call: ToolCallRequest,
-            tool: Any,
-            params: Any,
-            error: Any,
-        ) -> None:
-            events.append("error")
-
-    with pytest.raises(asyncio.CancelledError):
-        await execute_tool_calls(
-            tools,
-            [ToolCallRequest(id="call-1", name="demo", arguments={})],
-            concurrent=False,
-            external_lookup_counts={},
-            workspace_violation_counts={},
-            hook=RecordingHook(),
-            context=AgentHookContext(iteration=0, messages=[]),
-        )
-
-    assert events == ["before"]
-
-
-@pytest.mark.asyncio
-async def test_tool_execution_batches_read_only_tools_before_exclusive_work():
+async def test_runner_batches_read_only_tools_before_exclusive_work():
     tools = ToolRegistry()
     shared_events: list[str] = []
     read_a = _DelayTool("read_a", delay=0.05, read_only=True, shared_events=shared_events)
@@ -225,18 +184,24 @@ async def test_tool_execution_batches_read_only_tools_before_exclusive_work():
     tools.register(read_b)
     tools.register(write_a)
 
-    await execute_tool_calls(
-        tools,
+    provider = MagicMock()
+    runner = AgentRunner()
+    await runner._execute_tools(
+        make_run_spec(provider,
+            initial_messages=[],
+            tools=tools,
+            model="test-model",
+            max_iterations=1,
+            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+            concurrent_tools=True,
+        ),
         [
             ToolCallRequest(id="ro1", name="read_a", arguments={}),
             ToolCallRequest(id="ro2", name="read_b", arguments={}),
             ToolCallRequest(id="rw1", name="write_a", arguments={}),
         ],
-        concurrent=True,
-        external_lookup_counts={},
-        workspace_violation_counts={},
-        hook=AgentHook(),
-        context=AgentHookContext(iteration=0, messages=[]),
+        {},
+        {},
     )
 
     assert shared_events[0:2] == ["start:read_a", "start:read_b"]
@@ -247,7 +212,7 @@ async def test_tool_execution_batches_read_only_tools_before_exclusive_work():
 
 
 @pytest.mark.asyncio
-async def test_tool_execution_does_not_batch_exclusive_read_only_tools():
+async def test_runner_does_not_batch_exclusive_read_only_tools():
     tools = ToolRegistry()
     shared_events: list[str] = []
     read_a = _DelayTool("read_a", delay=0.03, read_only=True, shared_events=shared_events)
@@ -263,18 +228,24 @@ async def test_tool_execution_does_not_batch_exclusive_read_only_tools():
     tools.register(ddg_like)
     tools.register(read_b)
 
-    await execute_tool_calls(
-        tools,
+    provider = MagicMock()
+    runner = AgentRunner()
+    await runner._execute_tools(
+        make_run_spec(provider,
+            initial_messages=[],
+            tools=tools,
+            model="test-model",
+            max_iterations=1,
+            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
+            concurrent_tools=True,
+        ),
         [
             ToolCallRequest(id="ro1", name="read_a", arguments={}),
             ToolCallRequest(id="ddg1", name="ddg_like", arguments={}),
             ToolCallRequest(id="ro2", name="read_b", arguments={}),
         ],
-        concurrent=True,
-        external_lookup_counts={},
-        workspace_violation_counts={},
-        hook=AgentHook(),
-        context=AgentHookContext(iteration=0, messages=[]),
+        {},
+        {},
     )
 
     assert shared_events[0] == "start:read_a"

tests/agent/test_session_manager_history.py

@@ -1,11 +1,10 @@
+from nanobot.providers.base import ProviderConversationState
 from nanobot.runtime_context import (
     RUNTIME_CONTEXT_HISTORY_META,
     RuntimeContextBlock,
     append_runtime_context,
 )
-from nanobot.session.history_visibility import HIDDEN_HISTORY_META
 from nanobot.session.manager import Session, SessionManager
-from nanobot.session.summary import SUMMARY_CONTINUATION_TEXT
 
 
 def _assert_no_orphans(history: list[dict]) -> None:
@@ -137,15 +136,67 @@ def test_legitimate_tool_pairs_preserved_after_trim():
     assert history[0]["role"] == "user"
 
 
-# --- last_archived > 0 ---
+def test_retain_recent_legal_suffix_keeps_recent_messages():
+    session = Session(key="test:trim")
+    for i in range(10):
+        session.messages.append({"role": "user", "content": f"msg{i}"})
 
-def test_orphan_trim_with_last_archived():
-    """Orphan trimming works correctly when a session is partially archived."""
+    session.retain_recent_legal_suffix(4)
+
+    assert len(session.messages) == 4
+    assert session.messages[0]["content"] == "msg6"
+    assert session.messages[-1]["content"] == "msg9"
+
+
+def test_retain_recent_legal_suffix_adjusts_last_consolidated():
+    session = Session(key="test:trim-cons")
+    for i in range(10):
+        session.messages.append({"role": "user", "content": f"msg{i}"})
+    session.last_consolidated = 7
+
+    session.retain_recent_legal_suffix(4)
+
+    assert len(session.messages) == 4
+    assert session.last_consolidated == 1
+
+
+def test_retain_recent_legal_suffix_zero_clears_session():
+    session = Session(key="test:trim-zero")
+    for i in range(10):
+        session.messages.append({"role": "user", "content": f"msg{i}"})
+    session.last_consolidated = 5
+
+    session.retain_recent_legal_suffix(0)
+
+    assert session.messages == []
+    assert session.last_consolidated == 0
+
+
+def test_retain_recent_legal_suffix_keeps_legal_tool_boundary():
+    session = Session(key="test:trim-tools")
+    session.messages.append({"role": "user", "content": "old"})
+    session.messages.extend(_tool_turn("old", 0))
+    session.messages.append({"role": "user", "content": "keep"})
+    session.messages.extend(_tool_turn("keep", 0))
+    session.messages.append({"role": "assistant", "content": "done"})
+
+    session.retain_recent_legal_suffix(4)
+
+    history = session.get_history(max_messages=500)
+    _assert_no_orphans(history)
+    assert history[0]["role"] == "user"
+    assert history[0]["content"] == "keep"
+
+
+# --- last_consolidated > 0 ---
+
+def test_orphan_trim_with_last_consolidated():
+    """Orphan trimming works correctly when session is partially consolidated."""
     session = Session(key="test:consolidated")
     for i in range(10):
         session.messages.append({"role": "user", "content": f"old {i}"})
         session.messages.extend(_tool_turn("cons", i))
-    session.last_archived = 30
+    session.last_consolidated = 30
 
     session.messages.append({"role": "user", "content": "recent"})
     for i in range(15):
@@ -162,7 +213,7 @@ def test_get_history_replays_recent_messages_after_full_archive():
     for i in range(10):
         session.messages.append({"role": "user", "content": f"u{i}"})
         session.messages.append({"role": "assistant", "content": f"a{i}"})
-    session.last_archived = len(session.messages)
+    session.last_consolidated = len(session.messages)
 
     history = session.get_history(max_messages=100)
 
@@ -178,8 +229,8 @@ def test_get_history_replays_recent_messages_after_full_archive():
     ]
 
 
-def test_get_history_extends_archived_replay_to_preceding_user():
-    session = Session(key="test:archived-tool-turn")
+def test_get_history_extends_compacted_replay_to_preceding_user():
+    session = Session(key="test:compacted-tool-turn")
     session.messages.extend(
         [
             {"role": "user", "content": "old"},
@@ -191,7 +242,7 @@ def test_get_history_extends_archived_replay_to_preceding_user():
             {"role": "assistant", "content": "done"},
         ]
     )
-    session.last_archived = len(session.messages)
+    session.last_consolidated = len(session.messages)
 
     history = session.get_history(max_messages=100)
 
@@ -200,8 +251,8 @@ def test_get_history_extends_archived_replay_to_preceding_user():
     _assert_no_orphans(history)
 
 
-def test_archived_tool_turn_can_extend_past_message_cap():
-    session = Session(key="test:long-archived-tool-turn")
+def test_compacted_tool_turn_can_extend_past_message_cap():
+    session = Session(key="test:long-compacted-tool-turn")
     session.messages.extend(
         [
             {"role": "user", "content": "old"},
@@ -212,7 +263,7 @@ def test_archived_tool_turn_can_extend_past_message_cap():
     for i in range(50):
         session.messages.extend(_tool_turn("keep", i))
     session.messages.append({"role": "assistant", "content": "done"})
-    session.last_archived = len(session.messages)
+    session.last_consolidated = len(session.messages)
 
     history = session.get_history(max_messages=120)
 
@@ -584,41 +635,7 @@ def test_fork_session_allows_index_equal_to_user_count(tmp_path):
     assert [m["content"] for m in forked.messages] == ["round1", "answer1"]
 
 
-def test_fork_session_user_index_ignores_hidden_checkpoint_anchor(tmp_path):
-    manager = SessionManager(tmp_path)
-    source = manager.get_or_create("websocket:source")
-    source.add_message("user", "round1")
-    source.add_message("assistant", "answer1")
-    source.add_message("user", "round2")
-    source.add_message(
-        "user",
-        SUMMARY_CONTINUATION_TEXT,
-        **{HIDDEN_HISTORY_META: True},
-    )
-    source.add_message("assistant", "answer2")
-    source.last_archived = 3
-    source.metadata["_last_summary"] = {"text": "round1 and round2"}
-    manager.save(source)
-
-    forked = manager.fork_session_before_user_index(
-        "websocket:source",
-        "websocket:fork",
-        2,
-    )
-
-    assert forked is not None
-    assert [message["content"] for message in forked.messages] == [
-        "round1",
-        "answer1",
-        "round2",
-        SUMMARY_CONTINUATION_TEXT,
-        "answer2",
-    ]
-    assert forked.last_archived == 3
-    assert forked.metadata["_last_summary"]["text"] == "round1 and round2"
-
-
-def test_fork_session_drops_summary_when_fork_point_is_inside_archived_prefix(tmp_path):
+def test_fork_session_drops_summary_when_fork_point_is_inside_consolidated_prefix(tmp_path):
     manager = SessionManager(tmp_path)
     source = manager.get_or_create("websocket:source")
     source.messages = [
@@ -627,7 +644,7 @@ def test_fork_session_drops_summary_when_fork_point_is_inside_archived_prefix(tm
         {"role": "user", "content": "round2 fork me"},
         {"role": "assistant", "content": "answer2"},
     ]
-    source.last_archived = 4
+    source.last_consolidated = 4
     source.metadata["_last_summary"] = {"text": "round2 fork me and answer2"}
     manager.save(source)
 
@@ -639,7 +656,7 @@ def test_fork_session_drops_summary_when_fork_point_is_inside_archived_prefix(tm
 
     assert forked is not None
     assert [m["content"] for m in forked.messages] == ["round1", "answer1"]
-    assert forked.last_archived == 0
+    assert forked.last_consolidated == 0
     assert "_last_summary" not in forked.metadata
 
 
@@ -739,6 +756,44 @@ def test_get_history_recovers_user_when_token_slice_would_be_assistant_only(monk
     assert [m["content"] for m in history] == ["u2", "a2"]
 
 
+def test_retain_recent_legal_suffix_hard_cap_with_long_non_user_chain():
+    session = Session(key="test:hard-cap-chain")
+    session.messages.append({"role": "user", "content": "u0"})
+    session.messages.append(
+        {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {"id": "c1", "type": "function", "function": {"name": "x", "arguments": "{}"}}
+            ],
+        }
+    )
+    for i in range(12):
+        session.messages.append({"role": "assistant", "content": f"a{i}"})
+
+    session.retain_recent_legal_suffix(6)
+
+    assert len(session.messages) <= 6
+
+
+def test_retain_recent_legal_suffix_can_extend_to_user_for_long_recent_turn():
+    session = Session(key="test:extend-to-user")
+    session.messages.append({"role": "user", "content": "old"})
+    session.messages.append({"role": "assistant", "content": "old answer"})
+    session.messages.append({"role": "user", "content": "record this"})
+    for i in range(4):
+        session.messages.extend(_tool_turn("recent", i))
+    session.messages.append({"role": "assistant", "content": "done"})
+
+    session.retain_recent_legal_suffix(8, extend_to_user=True)
+
+    assert len(session.messages) > 8
+    assert session.messages[0]["content"] == "record this"
+    assert session.messages[-1]["content"] == "done"
+    history = session.get_history(max_messages=500)
+    _assert_no_orphans(history)
+
+
 def test_get_history_can_extend_to_user_for_long_recent_turn():
     session = Session(key="test:history-extend-to-user")
     session.messages.append({"role": "user", "content": "old"})
@@ -773,3 +828,83 @@ def test_get_history_extend_to_user_keeps_newer_user_inside_window():
 
     assert [m["content"] for m in history] == ["new question", "new answer"]
     _assert_no_orphans(history)
+
+
+def test_retain_recent_legal_suffix_returns_dropped_messages():
+    """retain_recent_legal_suffix returns the actually-dropped messages."""
+    session = Session(
+        key="test:return-dropped",
+        provider_state=ProviderConversationState(
+            kind="openai_responses",
+            provider="openai:test",
+            model="test-model",
+            version=1,
+            payload={"items": []},
+        ),
+    )
+    for i in range(10):
+        session.messages.append({"role": "user", "content": f"msg{i}"})
+
+    result = session.retain_recent_legal_suffix(4)
+
+    assert len(result.dropped) == 6
+    assert [m["content"] for m in result.dropped] == [f"msg{i}" for i in range(6)]
+    assert len(session.messages) == 4
+    assert result.already_consolidated_count == 0
+    assert session.provider_state is None
+
+
+def test_retain_recent_legal_suffix_returns_empty_when_no_drop():
+    """No messages dropped → empty list returned."""
+    state = ProviderConversationState(
+        kind="openai_responses",
+        provider="openai:test",
+        model="test-model",
+        version=1,
+        payload={"items": []},
+    )
+    session = Session(key="test:no-drop", provider_state=state)
+    for i in range(3):
+        session.messages.append({"role": "user", "content": f"msg{i}"})
+
+    result = session.retain_recent_legal_suffix(4)
+
+    assert result.dropped == []
+    assert result.already_consolidated_count == 0
+    assert len(session.messages) == 3
+    assert session.provider_state is state
+
+
+def test_retain_recent_legal_suffix_returns_all_on_zero():
+    """max_messages=0 clears session and returns all messages."""
+    session = Session(key="test:zero-return")
+    for i in range(5):
+        session.messages.append({"role": "user", "content": f"msg{i}"})
+    session.last_consolidated = 3
+
+    result = session.retain_recent_legal_suffix(0)
+
+    assert len(result.dropped) == 5
+    assert result.already_consolidated_count == 3
+    assert session.messages == []
+
+
+def test_retain_recent_legal_suffix_last_consolidated_correct_in_else_branch():
+    """last_consolidated after retain_recent_legal_suffix should reflect how
+    many retained messages were inside the old consolidated prefix."""
+    session = Session(key="test:else-lc-correct")
+    # 20 messages: u0..u9, a0..a9
+    for i in range(10):
+        session.messages.append({"role": "user", "content": f"u{i}"})
+    for i in range(10):
+        session.messages.append({"role": "assistant", "content": f"a{i}"})
+    session.last_consolidated = 12  # u0..u9, a0, a1 consolidated
+
+    result = session.retain_recent_legal_suffix(4)
+
+    # Retained messages start from latest user (u9) + max_messages forward
+    # so retained = [u9, a0..a9][:4] → but these are from original indices 9..12
+    # Of those, indices 9,10,11 are < 12 (before_lc), so new_lc = 3
+    assert session.last_consolidated == 3
+    # already_cons should count dropped messages with original index < 12
+    assert result.already_consolidated_count == 9

tests/agent/test_session_model_runtime.py

@@ -114,7 +114,7 @@ async def test_removed_session_model_preset_falls_back_and_clears_metadata(tmp_p
         provider=base,
         workspace=tmp_path,
         model="base-model",
-        context_window_tokens=16_000,
+        context_window_tokens=8_000,
     )
     loop.schedule_background = lambda coro: coro.close()  # type: ignore[method-assign]
     session_key = "sdk:removed-preset"
@@ -196,7 +196,7 @@ async def test_sdk_custom_model_preset_metadata_does_not_select_runtime(
         provider=base,
         workspace=tmp_path,
         model="base-model",
-        context_window_tokens=16_000,
+        context_window_tokens=8_000,
     )
     loop.schedule_background = lambda coro: coro.close()  # type: ignore[method-assign]
     bot = Nanobot(loop)

tests/agent/test_session_retention.py

@@ -0,0 +1,225 @@
+from nanobot.session.manager import Session
+
+
+def _assert_no_orphans(history: list[dict]) -> None:
+    declared = {
+        tc["id"]
+        for m in history
+        if m.get("role") == "assistant"
+        for tc in (m.get("tool_calls") or [])
+    }
+    orphans = [
+        m.get("tool_call_id")
+        for m in history
+        if m.get("role") == "tool" and m.get("tool_call_id") not in declared
+    ]
+    assert orphans == [], f"orphan tool_call_ids: {orphans}"
+
+
+def _delivery(content: str) -> dict:
+    return {"role": "assistant", "content": content, "_channel_delivery": True}
+
+
+def _tool_turn(prefix: str, idx: int) -> list[dict]:
+    return [
+        {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": f"{prefix}_{idx}_a",
+                    "type": "function",
+                    "function": {"name": "x", "arguments": "{}"},
+                },
+                {
+                    "id": f"{prefix}_{idx}_b",
+                    "type": "function",
+                    "function": {"name": "y", "arguments": "{}"},
+                },
+            ],
+        },
+        {"role": "tool", "tool_call_id": f"{prefix}_{idx}_a", "name": "x", "content": "ok"},
+        {"role": "tool", "tool_call_id": f"{prefix}_{idx}_b", "name": "y", "content": "ok"},
+    ]
+
+
+def _contents(messages: list[dict]) -> list[str]:
+    return [m.get("content") for m in messages]
+
+
+def _has_delivery(messages: list[dict]) -> bool:
+    return any(m.get("_channel_delivery") for m in messages)
+
+
+# --- Hard-cap trimming must preserve a proactive delivery the user replied to ---
+
+
+def test_retain_hard_cap_keeps_delivery_before_user():
+    session = Session(key="test:cap-delivery")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append(_delivery("Remember to drink water"))
+    session.messages.append({"role": "user", "content": "ok"})
+    session.messages.append({"role": "assistant", "content": "great"})
+
+    session.retain_recent_legal_suffix(3)
+
+    assert _has_delivery(session.messages), "delivery dropped by hard-cap trim"
+    assert _contents(session.messages) == [
+        "Remember to drink water",
+        "ok",
+        "great",
+    ]
+
+
+def test_retain_hard_cap_matches_get_history_boundary():
+    """The trimmed suffix must start on the same message as get_history()."""
+    session = Session(key="test:cap-boundary")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append(_delivery("You have 3 pending tasks"))
+    session.messages.append({"role": "user", "content": "show them"})
+    session.messages.append({"role": "assistant", "content": "done"})
+
+    expected = session.get_history(max_messages=3)
+
+    session.retain_recent_legal_suffix(3)
+
+    assert _contents(session.messages) == _contents(expected)
+
+
+def test_retain_extend_to_user_keeps_delivery_before_recovered_user():
+    session = Session(key="test:extend-delivery")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append({"role": "assistant", "content": "work"})
+    session.messages.append(_delivery("Reminder: deploy at 17:00"))
+    session.messages.append({"role": "user", "content": "ok"})
+    session.messages.append({"role": "assistant", "content": "a1"})
+    session.messages.append({"role": "assistant", "content": "a2"})
+    session.messages.append({"role": "assistant", "content": "a3"})
+
+    session.retain_recent_legal_suffix(3, extend_to_user=True)
+
+    assert _has_delivery(session.messages), "delivery dropped by extend_to_user trim"
+    assert session.messages[0]["content"] == "Reminder: deploy at 17:00"
+    assert session.messages[-1]["content"] == "a3"
+
+
+def test_retain_extend_to_user_matches_get_history_boundary():
+    session = Session(key="test:extend-boundary")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append({"role": "assistant", "content": "work"})
+    session.messages.append(_delivery("Reminder: review the draft"))
+    session.messages.append({"role": "user", "content": "ok"})
+    session.messages.append({"role": "assistant", "content": "a1"})
+    session.messages.append({"role": "assistant", "content": "a2"})
+    session.messages.append({"role": "assistant", "content": "a3"})
+
+    expected = session.get_history(max_messages=3, extend_to_user=True)
+
+    session.retain_recent_legal_suffix(3, extend_to_user=True)
+
+    assert _contents(session.messages) == _contents(expected)
+
+
+def test_retain_extend_to_user_does_not_extend_delivery_only_tail():
+    session = Session(key="test:extend-no-user")
+    for i in range(4):
+        session.messages.append(_delivery(f"notification {i}"))
+
+    session.retain_recent_legal_suffix(3, extend_to_user=True)
+
+    assert _contents(session.messages) == [
+        "notification 1",
+        "notification 2",
+        "notification 3",
+    ]
+
+
+# --- Only the immediately-preceding delivery is part of the anchor ---
+
+
+def test_retain_keeps_only_immediate_delivery():
+    session = Session(key="test:multi-delivery")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append(_delivery("old scheduled note"))
+    session.messages.append(_delivery("new scheduled note"))
+    session.messages.append({"role": "user", "content": "ok"})
+    session.messages.append({"role": "assistant", "content": "great"})
+
+    session.retain_recent_legal_suffix(3)
+
+    kept = _contents(session.messages)
+    assert kept == ["new scheduled note", "ok", "great"], kept
+
+
+def test_retain_drops_delivery_not_adjacent_to_anchor_user():
+    """A delivery that does not immediately precede the retained user turn is
+    not part of the anchor and should not be force-retained."""
+    session = Session(key="test:nonadjacent")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append(_delivery("unrelated scheduled note"))
+    session.messages.append({"role": "assistant", "content": "reply"})
+    session.messages.append({"role": "user", "content": "ok"})
+    session.messages.append({"role": "assistant", "content": "great"})
+
+    session.retain_recent_legal_suffix(2)
+
+    assert not _has_delivery(session.messages)
+    assert _contents(session.messages) == ["ok", "great"]
+
+
+def test_compact_probe_keeps_delivery_in_visible_suffix():
+    """compact_idle_session() trims a probe copy with extend_to_user=True; the
+    visible suffix it keeps must still contain the delivery message."""
+    tail = [
+        {"role": "user", "content": "setup"},
+        {"role": "assistant", "content": "work"},
+        _delivery("Reminder: deploy at 17:00"),
+        {"role": "user", "content": "ok"},
+        {"role": "assistant", "content": "a1"},
+        {"role": "assistant", "content": "a2"},
+        {"role": "assistant", "content": "a3"},
+    ]
+    probe = Session(key="test:probe", messages=tail, last_consolidated=0)
+
+    probe.retain_recent_legal_suffix(3, extend_to_user=True)
+
+    assert _has_delivery(probe.messages)
+    assert probe.messages[0]["content"] == "Reminder: deploy at 17:00"
+
+
+# --- Trimming must stay coherent with the rest of replay ---
+
+
+def test_retain_then_replay_keeps_delivery_and_no_orphans():
+    session = Session(key="test:replay-after-trim")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append(_delivery("You have 3 pending tasks"))
+    session.messages.append({"role": "user", "content": "show them"})
+    session.messages.extend(_tool_turn("cur", 0))
+    session.messages.append({"role": "assistant", "content": "done"})
+
+    session.retain_recent_legal_suffix(6)
+
+    assert _has_delivery(session.messages)
+    history = session.get_history(max_messages=500)
+    _assert_no_orphans(history)
+    assert any(m.get("content") == "You have 3 pending tasks" for m in history)
+
+
+def test_retain_keeps_delivery_when_user_inside_window():
+    """When the capped window already contains a user, its immediately
+    preceding delivery must stay attached to it."""
+    session = Session(key="test:window-user")
+    session.messages.append({"role": "user", "content": "setup"})
+    session.messages.append({"role": "assistant", "content": "a0"})
+    session.messages.append(_delivery("Reminder"))
+    session.messages.append({"role": "user", "content": "ok"})
+    session.messages.append({"role": "assistant", "content": "a1"})
+    session.messages.append({"role": "assistant", "content": "a2"})
+
+    expected = session.get_history(max_messages=4)
+
+    session.retain_recent_legal_suffix(4)
+
+    assert _has_delivery(session.messages)
+    assert _contents(session.messages) == _contents(expected)

tests/agent/test_subagent_lifecycle.py

@@ -520,35 +520,6 @@ class TestCancelBySession:
         count = await sm.cancel_by_session("nonexistent")
         assert count == 0
 
-    @pytest.mark.asyncio
-    async def test_cancels_active_and_queued_tasks(self, tmp_path):
-        sm = _manager(tmp_path, max_concurrent_subagents=1)
-        active_entered = asyncio.Event()
-        queued_entered = asyncio.Event()
-
-        async def _blocked_run(spec):
-            task = spec.initial_messages[-1]["content"]
-            if task == "active":
-                active_entered.set()
-            else:
-                queued_entered.set()
-            await asyncio.Event().wait()
-
-        sm.runner.run = _blocked_run
-        runtime = _runtime()
-        await sm.spawn("active", runtime=runtime, session_key="s1")
-        await asyncio.wait_for(active_entered.wait(), timeout=1.0)
-        await sm.spawn("queued", runtime=runtime, session_key="s1")
-        await asyncio.sleep(0)
-
-        assert not queued_entered.is_set()
-        assert await sm.cancel_by_session("s1") == 2
-        await asyncio.sleep(0)
-
-        assert not queued_entered.is_set()
-        assert sm._running_tasks == {}
-        assert sm._session_tasks == {}
-
     @pytest.mark.asyncio
     async def test_already_done_not_counted(self, tmp_path):
         sm = _manager(tmp_path)

tests/agent/test_task_cancel.py

@@ -42,65 +42,6 @@ def _make_loop(*, tools_config=None):
     return loop, bus
 
 
-class TestActiveTaskTracking:
-    @pytest.mark.asyncio
-    async def test_completed_task_removes_empty_session_group(self):
-        loop, _bus = _make_loop()
-        release = asyncio.Event()
-        task = asyncio.create_task(release.wait())
-
-        loop._track_active_task("test:c1", task)
-        release.set()
-        await task
-        await asyncio.sleep(0)
-
-        assert "test:c1" not in loop._active_tasks
-
-    @pytest.mark.asyncio
-    async def test_session_group_remains_until_last_task_completes(self):
-        loop, _bus = _make_loop()
-        releases = [asyncio.Event(), asyncio.Event()]
-        tasks = [asyncio.create_task(release.wait()) for release in releases]
-        for task in tasks:
-            loop._track_active_task("test:c1", task)
-
-        releases[0].set()
-        await tasks[0]
-        await asyncio.sleep(0)
-
-        assert loop._active_tasks["test:c1"] == {tasks[1]}
-
-        releases[1].set()
-        await tasks[1]
-        await asyncio.sleep(0)
-
-        assert "test:c1" not in loop._active_tasks
-
-    @pytest.mark.asyncio
-    async def test_old_callback_preserves_replacement_session_group(self):
-        loop, _bus = _make_loop()
-        old_release = asyncio.Event()
-        new_release = asyncio.Event()
-        old_task = asyncio.create_task(old_release.wait())
-        new_task = asyncio.create_task(new_release.wait())
-
-        loop._track_active_task("test:c1", old_task)
-        loop._active_tasks.pop("test:c1")
-        loop._track_active_task("test:c1", new_task)
-
-        old_release.set()
-        await old_task
-        await asyncio.sleep(0)
-
-        assert loop._active_tasks["test:c1"] == {new_task}
-
-        new_release.set()
-        await new_task
-        await asyncio.sleep(0)
-
-        assert "test:c1" not in loop._active_tasks
-
-
 class TestHandleStop:
     @pytest.mark.asyncio
     async def test_stop_no_active_task(self):
@@ -313,7 +254,7 @@ class TestDispatch:
         assert isinstance(second.event, StreamEndEvent)
 
     @pytest.mark.asyncio
-    async def test_same_session_dispatches_serialize(self):
+    async def test_processing_lock_serializes(self):
         from nanobot.bus.events import InboundMessage, OutboundMessage
 
         loop, bus = _make_loop()

tests/agent/test_unified_session.py

@@ -28,7 +28,7 @@ from nanobot.command.router import CommandContext, CommandRouter
 from nanobot.config.schema import AgentDefaults, Config
 from nanobot.providers.base import GenerationSettings
 from nanobot.session.keys import UNIFIED_SESSION_KEY
-from nanobot.session.manager import SessionManager
+from nanobot.session.manager import Session, SessionManager
 from nanobot.utils.llm_runtime import LLMRuntime
 
 # ---------------------------------------------------------------------------
@@ -291,7 +291,7 @@ class TestCmdNewUnifiedSession:
         archived = loop.consolidator.archive_session.call_args.args[0]
         assert archived.key == "unified:default"
         assert archived.messages == expected_snapshot
-        assert archived.last_archived == 0
+        assert archived.last_consolidated == 0
         loop.consolidator.archive_session.assert_called_once_with(
             archived,
             archive_end=len(expected_snapshot),
@@ -334,6 +334,116 @@ class TestCmdNewUnifiedSession:
         assert len(sessions.get_or_create("discord:999").messages) == 1
 
 
+# ---------------------------------------------------------------------------
+# TestConsolidationUnaffectedByUnifiedSession — consolidation is key-agnostic
+# ---------------------------------------------------------------------------
+
+class TestConsolidationUnaffectedByUnifiedSession:
+    """maybe_consolidate_by_tokens() behaviour is identical regardless of session key."""
+
+    @pytest.mark.asyncio
+    async def test_consolidation_skips_empty_session_for_unified_key(self):
+        """Empty unified:default session → consolidation exits immediately, archive not called."""
+        from nanobot.agent.memory import Consolidator, MemoryStore
+
+        store = MagicMock(spec=MemoryStore)
+        mock_provider = MagicMock()
+        mock_provider.chat_with_retry = AsyncMock(return_value=MagicMock(content="summary"))
+        runtime = _runtime(mock_provider)
+        # Use spec= so MagicMock doesn't auto-generate AsyncMock for non-async methods,
+        # which would leave unawaited coroutines and trigger RuntimeWarning.
+        sessions = MagicMock(spec=SessionManager)
+
+        consolidator = Consolidator(
+            store=store,
+            sessions=sessions,
+            build_messages=MagicMock(return_value=[]),
+            get_tool_definitions=MagicMock(return_value=[]),
+        )
+        consolidator.archive_session = AsyncMock()
+
+        session = Session(key="unified:default")
+        session.messages = []
+        sessions.get_or_create.return_value = session
+
+        await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+
+        consolidator.archive_session.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_consolidation_behaviour_identical_for_any_key(self):
+        """Archive call count is the same for 'telegram:123' and 'unified:default'
+        under identical token conditions."""
+        from nanobot.agent.memory import Consolidator, MemoryStore
+
+        archive_calls: dict[str, int] = {}
+
+        for key in ("telegram:123", "unified:default"):
+            store = MagicMock(spec=MemoryStore)
+            mock_provider = MagicMock()
+            mock_provider.chat_with_retry = AsyncMock(return_value=MagicMock(content="summary"))
+            runtime = _runtime(mock_provider)
+            sessions = MagicMock(spec=SessionManager)
+
+            consolidator = Consolidator(
+                store=store,
+                sessions=sessions,
+                build_messages=MagicMock(return_value=[]),
+                get_tool_definitions=MagicMock(return_value=[]),
+            )
+
+            session = Session(key=key)
+            session.messages = []  # empty → exits immediately for both keys
+            sessions.get_or_create.return_value = session
+
+            consolidator.archive_session = AsyncMock()
+            await consolidator.maybe_consolidate_by_tokens(
+                session,
+                runtime=runtime,
+            )
+            archive_calls[key] = consolidator.archive_session.call_count
+
+        assert archive_calls["telegram:123"] == archive_calls["unified:default"] == 0
+
+    @pytest.mark.asyncio
+    async def test_consolidation_triggers_when_over_budget_unified_key(self):
+        """When tokens exceed budget, consolidation attempts to find a boundary —
+        behaviour is identical to any other session key."""
+        from nanobot.agent.memory import Consolidator, MemoryStore
+
+        store = MagicMock(spec=MemoryStore)
+        mock_provider = MagicMock()
+        runtime = _runtime(mock_provider)
+        sessions = MagicMock(spec=SessionManager)
+
+        consolidator = Consolidator(
+            store=store,
+            sessions=sessions,
+            build_messages=MagicMock(return_value=[]),
+            get_tool_definitions=MagicMock(return_value=[]),
+        )
+
+        session = Session(key="unified:default")
+        session.messages = [{"role": "user", "content": "msg"}]
+        sessions.get_or_create.return_value = session
+
+        # Simulate over-budget: estimated > budget
+        consolidator.estimate_session_prompt_tokens = MagicMock(return_value=(950, "tiktoken"))
+        # No valid boundary found → returns gracefully without archiving
+        consolidator.pick_consolidation_boundary = MagicMock(return_value=None)
+        consolidator.archive_session = AsyncMock()
+
+        await consolidator.maybe_consolidate_by_tokens(session, runtime=runtime)
+
+        # estimate was called (consolidation was attempted)
+        consolidator.estimate_session_prompt_tokens.assert_called_once_with(
+            session,
+            runtime=runtime,
+        )
+        # but archive was not called (no valid boundary)
+        consolidator.archive_session.assert_not_called()
+
+
 # ---------------------------------------------------------------------------
 # TestStopCommandWithUnifiedSession — /stop command integration
 # ---------------------------------------------------------------------------

tests/agent/tools/test_subagent_tools.py

@@ -7,7 +7,6 @@ from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
-from nanobot.agent.context import TranscriptInput
 from nanobot.agent.tools.context import RequestContext
 from nanobot.config.schema import AgentDefaults
 from nanobot.providers.base import GenerationSettings
@@ -212,8 +211,8 @@ async def test_spawn_forwards_temperature_to_run_spec(tmp_path):
 
 
 @pytest.mark.asyncio
-async def test_background_spawn_waits_for_concurrency_capacity(tmp_path):
-    """Background tasks should be accepted and start when capacity becomes available."""
+async def test_spawn_tool_rejects_when_at_concurrency_limit(tmp_path):
+    """SpawnTool should return an error string when the concurrency limit is reached."""
     from nanobot.agent.subagent import SubagentManager
     from nanobot.agent.tools.spawn import SpawnTool
     from nanobot.bus.queue import MessageBus
@@ -225,23 +224,14 @@ async def test_background_spawn_waits_for_concurrency_capacity(tmp_path):
         workspace=tmp_path,
         bus=bus,
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-        max_concurrent_subagents=1,
     )
     mgr._announce_result = AsyncMock()
 
-    first_entered = asyncio.Event()
-    second_entered = asyncio.Event()
-    release_first = asyncio.Event()
-    release_second = asyncio.Event()
+    # Block the first subagent so it stays "running"
+    release = asyncio.Event()
 
     async def fake_run(spec):
-        task = spec.initial_messages[-1]["content"]
-        if task == "first task":
-            first_entered.set()
-            await release_first.wait()
-        else:
-            second_entered.set()
-            await release_second.wait()
+        await release.wait()
         return SimpleNamespace(
             stop_reason="done",
             final_content="done",
@@ -260,24 +250,19 @@ async def test_background_spawn_waits_for_concurrency_capacity(tmp_path):
         session_key="test:c1",
         runtime=_runtime(provider),
     )):
-        first_result = await tool.execute(task="first task")
-        assert "started" in first_result
-        await asyncio.wait_for(first_entered.wait(), timeout=1.0)
+        # First spawn succeeds
+        result = await tool.execute(task="first task")
+        assert "started" in result
 
-        second_result = await tool.execute(task="second task")
-        assert "started" in second_result
-        tasks = list(mgr._running_tasks.values())
-        await asyncio.sleep(0)
-        assert not second_entered.is_set()
-        phases = {status.task_description: status.phase for status in mgr._task_statuses.values()}
-        assert phases == {"first task": "initializing", "second task": "queued"}
+        # Second spawn should be rejected (default limit is 1)
+        result = await tool.execute(task="second task")
+        assert "Cannot spawn subagent" in result
+        assert "concurrency limit reached" in result
 
-    release_first.set()
-    await asyncio.wait_for(second_entered.wait(), timeout=1.0)
-    release_second.set()
-    await asyncio.gather(*tasks, return_exceptions=True)
-    await asyncio.sleep(0)
-    assert mgr._running_tasks == {}
+    # Release the first subagent
+    release.set()
+    # Allow cleanup
+    await asyncio.gather(*mgr._running_tasks.values(), return_exceptions=True)
 
 
 @pytest.mark.asyncio
@@ -315,7 +300,7 @@ async def test_spawn_tool_waits_for_inline_result():
 
 
 @pytest.mark.asyncio
-async def test_inline_spawn_waits_for_concurrency_capacity(tmp_path):
+async def test_inline_spawn_counts_toward_concurrency_limit(tmp_path):
     from nanobot.agent.subagent import SubagentManager
     from nanobot.agent.tools.context import RequestContext, request_context
     from nanobot.agent.tools.spawn import SpawnTool
@@ -327,19 +312,12 @@ async def test_inline_spawn_waits_for_concurrency_capacity(tmp_path):
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
         max_concurrent_subagents=1,
     )
-    first_entered = asyncio.Event()
-    second_entered = asyncio.Event()
-    release_first = asyncio.Event()
-    release_second = asyncio.Event()
+    release = asyncio.Event()
+    entered = asyncio.Event()
 
     async def fake_run(spec):
-        task = spec.initial_messages[-1]["content"]
-        if task == "first":
-            first_entered.set()
-            await release_first.wait()
-        else:
-            second_entered.set()
-            await release_second.wait()
+        entered.set()
+        await release.wait()
         return SimpleNamespace(
             stop_reason="done",
             final_content="done",
@@ -356,100 +334,19 @@ async def test_inline_spawn_waits_for_concurrency_capacity(tmp_path):
         runtime=_runtime(MagicMock()),
     )):
         first = asyncio.create_task(tool.execute(task="first", wait=True))
-        await asyncio.wait_for(first_entered.wait(), timeout=1.0)
+        await asyncio.wait_for(entered.wait(), timeout=1.0)
 
-        second = asyncio.create_task(tool.execute(task="second", wait=True))
-        await asyncio.sleep(0)
+        second = await tool.execute(task="second", wait=True)
 
-        assert not second.done()
-        assert not second_entered.is_set()
-        assert manager.get_running_count() == 2
-        release_first.set()
+        assert "concurrency limit reached" in second
+        assert manager.get_running_count() == 1
+        release.set()
         assert await first == "done"
-        await asyncio.wait_for(second_entered.wait(), timeout=1.0)
-        release_second.set()
-        assert await second == "done"
 
     assert manager.get_running_count() == 0
     assert manager._session_tasks == {}
 
 
-@pytest.mark.asyncio
-async def test_runner_executes_inline_spawn_batch_concurrently(tmp_path):
-    """Adjacent blocking consultations should share one concurrent tool batch."""
-    from nanobot.agent.hook import AgentHook, AgentHookContext
-    from nanobot.agent.subagent import SubagentManager
-    from nanobot.agent.tools.context import RequestContext, request_context
-    from nanobot.agent.tools.execution import execute_tool_calls
-    from nanobot.agent.tools.registry import ToolRegistry
-    from nanobot.agent.tools.spawn import SpawnTool
-    from nanobot.bus.queue import MessageBus
-    from nanobot.providers.base import ToolCallRequest
-
-    manager = SubagentManager(
-        workspace=tmp_path,
-        bus=MessageBus(),
-        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
-        max_concurrent_subagents=2,
-    )
-    both_entered = asyncio.Event()
-    release = asyncio.Event()
-    entered: list[str] = []
-
-    async def fake_run(spec):
-        entered.append(spec.initial_messages[-1]["content"])
-        if len(entered) == 2:
-            both_entered.set()
-        await release.wait()
-        return SimpleNamespace(
-            stop_reason="done",
-            final_content=spec.initial_messages[-1]["content"],
-            error=None,
-            tool_events=[],
-        )
-
-    manager.runner.run = AsyncMock(side_effect=fake_run)
-    tools = ToolRegistry()
-    tools.register(SpawnTool(manager))
-    runtime = _runtime(MagicMock())
-    calls = [
-        ToolCallRequest(
-            id="spawn-1",
-            name="spawn",
-            arguments={"task": "first", "wait": True},
-        ),
-        ToolCallRequest(
-            id="spawn-2",
-            name="spawn",
-            arguments={"task": "second", "wait": True},
-        ),
-    ]
-
-    with request_context(RequestContext(
-        channel="test",
-        chat_id="c1",
-        session_key="test:c1",
-        runtime=runtime,
-    )):
-        execution = asyncio.create_task(execute_tool_calls(
-            tools,
-            calls,
-            concurrent=True,
-            external_lookup_counts={},
-            workspace_violation_counts={},
-            hook=AgentHook(),
-            context=AgentHookContext(iteration=0, messages=[], session_key="test:c1"),
-        ))
-        await asyncio.wait_for(both_entered.wait(), timeout=1.0)
-        release.set()
-        results, events = await execution
-
-    assert set(entered) == {"first", "second"}
-    assert results == ["first", "second"]
-    assert [event["status"] for event in events] == ["ok", "ok"]
-    assert manager._running_tasks == {}
-
-
 @pytest.mark.asyncio
 async def test_cancel_by_session_cancels_inline_subagent(tmp_path):
     from nanobot.agent.subagent import SubagentManager
@@ -494,7 +391,6 @@ def test_subagent_default_max_concurrent_matches_agent_defaults(tmp_path):
         max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
     )
 
-    assert AgentDefaults().max_concurrent_subagents == 4
     assert mgr.max_concurrent_subagents == AgentDefaults().max_concurrent_subagents
 
 
@@ -569,10 +465,7 @@ async def test_agent_loop_syncs_updated_max_iterations_before_run(tmp_path):
     loop.runner.run = AsyncMock(side_effect=fake_run)
     loop.max_iterations = 55
 
-    await loop._run_agent_loop(
-        TranscriptInput(history=[], current_message=None),
-        runtime=loop.llm_runtime(),
-    )
+    await loop._run_agent_loop([], runtime=loop.llm_runtime())
 
     loop.runner.run.assert_awaited_once()
 
@@ -613,7 +506,7 @@ async def test_drain_pending_no_block_when_no_subagents(tmp_path):
 
     runtime = loop.llm_runtime()
     await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "test"}], current_message=None),
+        [{"role": "user", "content": "test"}],
         runtime=runtime,
         session=None,
         request_context=RequestContext(channel="test", chat_id="c1", runtime=runtime),
@@ -672,7 +565,7 @@ async def test_terminal_drain_timeout(tmp_path):
 
     runtime = loop.llm_runtime()
     await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "test"}], current_message=None),
+        [{"role": "user", "content": "test"}],
         runtime=runtime,
         session=session,
         request_context=RequestContext(
@@ -746,7 +639,7 @@ async def test_terminal_drain_reuses_one_timeout_budget(tmp_path):
     loop.subagents._running_tasks["sub-deadline-1"] = hang_task
 
     await loop._run_agent_loop(
-        TranscriptInput(history=[{"role": "user", "content": "test"}], current_message=None),
+        [{"role": "user", "content": "test"}],
         runtime=loop.llm_runtime(),
         session=session,
         pending_queue=pending_queue,