deepagents-code 0.1.52__tar.gz → 0.1.53__tar.gz

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/.gitignore

@@ -241,8 +241,10 @@ __marimo__/
 #claude
 .claude
 
-# Harbor local job output
+# Harbor local job output. `harbor-jobs/` is the per-suite variant the eval Makefile and
+# the CI workflow write to (`harbor-jobs/<category>`).
 jobs/
+harbor-jobs/
 
 .idea
 TEXTUAL_REFACTOR_PLAN.md

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/ARCHITECTURE.md

@@ -67,5 +67,7 @@ The main cost is the client/server boundary. When debugging, first decide which
 - For local setup and debugging, see [`DEVELOPMENT.md`](./DEVELOPMENT.md).
 - For command behavior, see [`COMMANDS.md`](./COMMANDS.md).
 - For lifecycle hooks (`hooks.json`), see [`HOOKS.md`](./HOOKS.md).
+- For cost estimates and local pricing overrides (`prices.json`), see
+  [`PRICING.md`](./PRICING.md).
 - For security boundaries, see [`THREAT_MODEL.md`](./THREAT_MODEL.md).
 - For package-specific coding conventions, see [`AGENTS.md`](./AGENTS.md).

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.53](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.52...deepagents-code==0.1.53) (2026-08-06)
+
+### Features
+
+- Added pricing coverage with Baseten built-in overrides and local fallback overrides when `genai-prices` is missing data ([#5312](https://github.com/langchain-ai/deepagents/issues/5312), [#5304](https://github.com/langchain-ai/deepagents/issues/5304)).
+- Suggest compacting large resumed threads ([#5318](https://github.com/langchain-ai/deepagents/issues/5318)).
+- Added terminal program trace metadata ([#5329](https://github.com/langchain-ai/deepagents/issues/5329)).
+
+### Bug Fixes
+
+- Preserved runtime offload archive routing ([#5328](https://github.com/langchain-ai/deepagents/issues/5328)).
+- Always restart after a successful startup auto-update ([#5317](https://github.com/langchain-ai/deepagents/issues/5317)).
+- Fixed leaked turn coroutines and SQLite handles ([#5218](https://github.com/langchain-ai/deepagents/issues/5218)).
+- Keep MCP shutdown-race tracebacks from appearing in the terminal ([#5325](https://github.com/langchain-ai/deepagents/issues/5325)).
+- Open the `/auto model` selector immediately while connecting ([#5341](https://github.com/langchain-ai/deepagents/issues/5341)).
+- Route failures to `PostToolUseFailure` ([#5315](https://github.com/langchain-ai/deepagents/issues/5315)).
+- Use dismissed copy for ask-user prompts ([#5331](https://github.com/langchain-ai/deepagents/issues/5331)).
+
 ## [0.1.52](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.51...deepagents-code==0.1.52) (2026-08-04)
 
 ### Features

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/HOOKS.md

@@ -54,7 +54,8 @@ Native tools are matched by their wire names (for example `execute` → `Bash`,
 | `PermissionRequest` | client | `tool_name` | The client is about to ask for tool permission |
 | `Notification` | client | `notification_type` | A client lifecycle notification is emitted |
 | `PreToolUse` | server | `tool_name` | Before a tool call runs |
-| `PostToolUse` | server | `tool_name` | After a tool call completes |
+| `PostToolUse` | server | `tool_name` | After a tool call succeeds |
+| `PostToolUseFailure` | server | `tool_name` | After a tool call fails |
 | `PreCompact` | server | `trigger` | Before conversation compaction |
 | `Stop` | server | _(none)_ | After an agent stop turn |
 | `SubagentStart` | server | `agent_name` | When a subagent starts |
@@ -127,7 +128,7 @@ Matchers use wire tool names. `execute` is exposed as `Bash`. Exit code `2` (or
 
 Handlers communicate through:
 
-- **Exit code `2`**: treated as a synthetic `decision: "block"`. Interpretation depends on the event (for example deny on `PreToolUse` / `PermissionRequest`, block further processing on `UserPromptSubmit` / `PreCompact`, feedback on `PostToolUse`).
+- **Exit code `2`**: treated as a synthetic `decision: "block"`. Interpretation depends on the event (for example deny on `PreToolUse` / `PermissionRequest`, block further processing on `UserPromptSubmit` / `PreCompact`, feedback on `PostToolUse` / `PostToolUseFailure`).
 - **Other non-zero exits**: recorded as diagnostics; they do not apply a block decision.
 - **JSON stdout** (`HookWireOutput`): may set `continue` / `stopReason`, `systemMessage` (user-visible notice), `additionalContext` via `hookSpecificOutput`, and event-specific fields such as `permissionDecision` on `PreToolUse`.
 - **Non-JSON stdout**: becomes additional context for events whose plain-output policy is context (`SessionStart`, `UserPromptSubmit`); otherwise it is a diagnostic.

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.52
+Version: 0.1.53
 Summary: Terminal coding agent built on the Deep Agents SDK - works with any model, with persistent memory, customizable skills, subagents, and approval controls.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -29,11 +29,11 @@ Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.22.1
 Requires-Dist: anyio<5.0.0,>=4.14.2
 Requires-Dist: deepagents-acp<1.0.0,>=0.0.9
-Requires-Dist: deepagents==0.7.1
+Requires-Dist: deepagents==0.7.4
 Requires-Dist: filelock<3.30,>=3.29.7
 Requires-Dist: genai-prices<0.2.0,>=0.1.1
 Requires-Dist: httpx<1.0.0,>=0.28.1
-Requires-Dist: langchain-anthropic<2.0.0,>=1.5.3
+Requires-Dist: langchain-anthropic<2.0.0,>=1.5.4
 Requires-Dist: langchain-google-genai<5.0.0,>=4.3.2
 Requires-Dist: langchain-mcp-adapters<1.0.0,>=0.3.0
 Requires-Dist: langchain-openai<2.0.0,>=1.4.1
@@ -65,7 +65,7 @@ Provides-Extra: agentcore
 Requires-Dist: langchain-agentcore-codeinterpreter<1.0.0,>=0.0.5; extra == 'agentcore'
 Provides-Extra: all-providers
 Requires-Dist: aiohttp<3.15.0,>=3.14.3; extra == 'all-providers'
-Requires-Dist: langchain-anthropic<2.0.0,>=1.5.3; extra == 'all-providers'
+Requires-Dist: langchain-anthropic<2.0.0,>=1.5.4; extra == 'all-providers'
 Requires-Dist: langchain-aws<2.0.0,>=1.6.3; extra == 'all-providers'
 Requires-Dist: langchain-baseten<1.0.0,>=0.2.3; extra == 'all-providers'
 Requires-Dist: langchain-cohere<1.0.0,>=0.6.0; extra == 'all-providers'
@@ -93,7 +93,7 @@ Requires-Dist: langchain-modal>=0.0.5; extra == 'all-sandboxes'
 Requires-Dist: langchain-runloop>=0.0.6; extra == 'all-sandboxes'
 Requires-Dist: langchain-vercel-sandbox>=0.0.1; extra == 'all-sandboxes'
 Provides-Extra: anthropic
-Requires-Dist: langchain-anthropic<2.0.0,>=1.5.3; extra == 'anthropic'
+Requires-Dist: langchain-anthropic<2.0.0,>=1.5.4; extra == 'anthropic'
 Provides-Extra: baseten
 Requires-Dist: langchain-baseten<1.0.0,>=0.2.3; extra == 'baseten'
 Provides-Extra: bedrock

deepagents_code-0.1.53/PRICING.md

@@ -0,0 +1,105 @@
+# Cost estimates and local pricing overrides
+
+`/cost` reports an estimate for the current thread. Rates come from
+[genai-prices](https://github.com/pydantic/genai-prices), which ships an offline
+catalog and refreshes it hourly in the background (opt out with
+`DEEPAGENTS_CODE_PRICES_AUTO_UPDATE=0`, or `[update].prices_auto_update = false`
+in `config.toml`).
+
+Estimates are display-only. Nothing in dcode caps spend or gates execution on
+them, so a wrong rate costs you an inaccurate number and nothing else.
+
+## When a model has no rates
+
+A model the catalog does not cover is left out of the total. `/cost` distinguishes
+that from a genuinely free request: it reports how many of the recorded requests
+are included in the figure.
+
+That happens with a newly released model, a self-hosted or proxied endpoint, or a
+provider name that does not line up with what genai-prices calls it. If you would
+rather see an estimate than a gap, write your own rates to:
+
+```
+~/.deepagents/prices.json
+```
+
+The file is read once, on the first request that needs it. **Edits take effect on
+the next dcode start**, not mid-session.
+
+## File format
+
+`prices.json` uses the same provider-array schema as genai-prices' own
+`prices/new_data/v2/data.json`, so an entry can be contributed upstream as-is.
+It is a JSON array of providers:
+
+```json
+[
+  {
+    "id": "my-proxy",
+    "name": "My proxy",
+    "api_pattern": "gateway\\.example\\.internal",
+    "models": [
+      {
+        "id": "house-model-v2",
+        "match": { "equals": "house-model-v2" },
+        "prices": { "input_mtok": 2.5, "output_mtok": 10.0 }
+      }
+    ]
+  }
+]
+```
+
+Required, and easy to omit:
+
+| Field | Where | Notes |
+| --- | --- | --- |
+| `id` | provider | Must be the provider id dcode reports for the request — see below. |
+| `name` | provider | Any display string. |
+| `api_pattern` | provider | Regex against the API URL. Unused by dcode, but the schema requires it. |
+| `id` | model | Any identifier; used in log messages. |
+| `match` | model | How to recognize the model: `{"equals": ...}`, `{"starts_with": ...}`, `{"contains": ...}`, or `{"regex": ...}`. |
+| `prices` | model | At least one rate. |
+
+Rates are per million tokens: `input_mtok`, `output_mtok`, and optionally
+`cache_read_mtok`, `cache_write_mtok`, `output_reasoning_mtok`,
+`input_audio_mtok`. Only list a bucket you have a real rate for — tokens in an
+omitted bucket are billed at the ordinary input or output rate rather than being
+dropped.
+
+## Getting the provider id right
+
+This is where a hand-written file usually goes wrong. dcode resolves the
+LangChain provider name through its own alias table before looking anything up,
+so the id it searches on is not always the string you would expect.
+
+If no provider in your file claims that id, dcode falls back to searching **every**
+provider in the file by model id alone. That keeps your entry reachable, but it
+also means an entry can price a request that ran against a different provider —
+`llama-3.3-70b` costs very different amounts on Bedrock, Together, and Groq. When
+that happens you get a warning naming both providers; pin the entry by using the
+id from the warning.
+
+## Diagnosing a file that is not working
+
+Everything below is logged to the Debug Console (`Ctrl+\`), each message once per
+session:
+
+| What you see | What it means |
+| --- | --- |
+| Nothing at all, cost still missing | The file is not where dcode looks, or is empty. Both are silent by design. |
+| "No pricing override matched model=… though … contributed N model entries" | The file loaded, but nothing matched. The `provider_id` in the message is the post-alias id your entry must use. |
+| "Could not parse … as JSON" / "must be an array of providers" | Syntax or shape problem. The payload must be a bare array, not `{"providers": [...]}`. |
+| "the entries failed validation against the genai-prices provider schema" | A required field is missing or mistyped. |
+| "the request ran against provider …" | Priced by a sweep, possibly from the wrong provider's entry. See above. |
+| "its entry matched but its rates were rejected" | A rate is unusable — negative, or large enough to overflow. |
+
+A malformed `prices.json` never breaks a model turn and never disables ordinary
+pricing: the bad source is dropped and everything else still prices.
+
+## Built-in stopgaps
+
+dcode also ships a small maintainer-curated catalog for models upstream has not
+priced yet. Your file wins over it on a conflicting `(provider id, model id)`
+pair, and both are consulted only when genai-prices itself has no rates. See
+[`deepagents_code/bundled_prices.README.md`](./deepagents_code/bundled_prices.README.md)
+for that policy.

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/deepagents_code/_ask_user_types.py

@@ -195,9 +195,11 @@ ASK_USER_CANCELLED_SUMMARY = "Question cancelled"
 Rewording it changes that hook contract. Not rendered on any row: a live cancel
 calls `set_rejected` (which records no output), and a transcript of `(cancelled)`
 placeholders from a non-TUI client is summarized from the recorded status like
-any other, so it reads as `ASK_USER_ANSWERED_SUMMARY`. The cancel banner in
-`textual_adapter` shares this wording but deliberately not this constant — it is
-user-facing prose, not the hook contract.
+any other, so it reads as `ASK_USER_ANSWERED_SUMMARY`. The dismissal banner in
+`textual_adapter` deliberately does not use this constant, and no longer even
+shares its wording — the banner says "dismissed" where this says "cancelled".
+That divergence is intentional: the banner is user-facing prose free to be
+reworded, this is the hook contract. Do not "de-duplicate" them.
 """
 
 ASK_USER_FAILED_SUMMARY: AskUserRowSummary = "Question failed"

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "b428644"
+BUILD_COMMIT = "0bd15dc"

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/deepagents_code/_version.py

@@ -2,7 +2,7 @@
 
 # Keep the `x-release-please-version` annotation — release-please uses it to
 # bump `__version__` in sync with `pyproject.toml` on every release PR.
-__version__ = "0.1.52"  # x-release-please-version
+__version__ = "0.1.53"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.52 → deepagents_code-0.1.53}/deepagents_code/app.py

@@ -354,6 +354,20 @@ def _coerce_provisional_cost_delta_usd(value: object) -> float | None:
     return delta_usd
 
 
+def _persisted_context_tokens(state_values: dict[str, Any]) -> int:
+    """Read a checkpoint's `_context_tokens`, coercing absent or invalid to 0.
+
+    Args:
+        state_values: Thread state values from the checkpoint.
+
+    Returns:
+        The persisted context size, or 0 when it is missing or not a
+        non-negative `int`.
+    """
+    raw = state_values.get("_context_tokens")
+    return raw if isinstance(raw, int) and raw >= 0 else 0
+
+
 def _warn_discarded_goal_channels(state_values: dict[str, Any]) -> list[str]:
     """Report persisted goal/rubric channels that are present but malformed.
 
@@ -9337,6 +9351,8 @@ class DeepAgentsApp(App):
                         ),
                     )
                     return
+                if start_cause is SessionStartCause.RESUME:
+                    await self._restore_resumed_context_tokens()
 
             if not await self._run_session_start_hook(start_cause):
                 self._initial_session_start_stopped = True
@@ -9349,6 +9365,9 @@ class DeepAgentsApp(App):
                 self._startup_cmd = None
                 await self._run_startup_command(cmd)
 
+            if start_cause is SessionStartCause.RESUME:
+                await self._maybe_compact_after_resume()
+
             if should_load_history:
                 await self._remount_pending_goal_rubric_review()
 
@@ -10173,6 +10192,7 @@ class DeepAgentsApp(App):
         from deepagents_code.command_registry import (
             BYPASS_WHEN_CONNECTING,
             IMMEDIATE_UI,
+            IMMEDIATE_UI_ARG_FORMS,
             SIDE_EFFECT_FREE,
             STARTUP_RECOVERY_COMMANDS,
         )
@@ -10200,11 +10220,16 @@ class DeepAgentsApp(App):
                 or self._modal_command_running()
             )
         if cmd in IMMEDIATE_UI:
-            # Only bare form (no args) bypasses — the selector-opening form is
-            # safe, but an argument form does a direct action that shouldn't
-            # race the agent (e.g. `/model <name>` switches models, `/threads
-            # -r <id>` resumes a thread).
-            return value == cmd
+            # Only UI-opening forms bypass: the bare command, or an argument
+            # form whitelisted in IMMEDIATE_UI_ARG_FORMS (e.g. `/auto model`,
+            # which opens the classifier picker). Other argument forms do a
+            # direct action that shouldn't race the agent (e.g. `/model <name>`
+            # switches models, `/threads -r <id>` resumes a thread,
+            # `/auto model <spec>` mutates classifier state). Whitespace is
+            # canonicalized for the whitelist check because `_handle_command`
+            # strips and reparses the same way — `/auto  model` (double space,
+            # tab) reaches the selector branch once processed.
+            return value == cmd or " ".join(value.split()) in IMMEDIATE_UI_ARG_FORMS
         return cmd in SIDE_EFFECT_FREE
 
     async def _submit_input(
@@ -15388,15 +15413,29 @@ class DeepAgentsApp(App):
                 if self._chat_input:
                     self._chat_input.set_cursor_active(active=False)
 
+                from functools import partial
+
                 # Use run_worker to avoid blocking the main event loop
                 # This allows the UI to remain responsive during agent execution
-                self._agent_worker = self.run_worker(
-                    self._run_agent_task(
-                        message,
-                        message_kwargs=message_kwargs,
-                        goal_notice_current=resuming_blocked,
-                    ),
-                    exclusive=False,
+                #
+                # Passed as a callable rather than a coroutine: a worker
+                # cancelled before its first event-loop step never runs its
+                # work, and an already-built coroutine would then be finalized
+                # unawaited (`RuntimeWarning`, plus an unraisable exception when
+                # the interpreter is far enough into teardown). Building it
+                # inside the worker means nothing exists to strand.
+                turn: Callable[[], Coroutine[None, None, None]] = partial(
+                    self._run_agent_task,
+                    message,
+                    message_kwargs=message_kwargs,
+                    goal_notice_current=resuming_blocked,
+                )
+                # Cast because Textual's `WorkType` alias admits both a
+                # coroutine factory and a plain callable, so the result type
+                # infers as the union rather than the `None` the turn returns.
+                self._agent_worker = cast(
+                    "Worker[None]",
+                    self.run_worker(turn, name="_run_agent_task", exclusive=False),
                 )
                 worker_started = True
             finally:
@@ -16488,10 +16527,7 @@ class DeepAgentsApp(App):
             context-token count, and the persisted model spec (if any).
         """
         state_values = await self._get_thread_state_values(thread_id)
-        raw_tokens = state_values.get("_context_tokens")
-        context_tokens = (
-            raw_tokens if isinstance(raw_tokens, int) and raw_tokens >= 0 else 0
-        )
+        context_tokens = _persisted_context_tokens(state_values)
         raw_spec = state_values.get("_model_spec")
         model_spec = raw_spec if isinstance(raw_spec, str) else ""
         raw_params = state_values.get("_model_params")
@@ -19049,9 +19085,9 @@ class DeepAgentsApp(App):
             "  /auto model <provider:model>\n"
             "  /auto model clear          Reuse the main agent model\n\n"
             "Auto reviews gated actions with a classifier model. It currently "
-            f"uses {self._auto_classifier_model_label()}. A weaker model makes "
-            "that review weaker; actions it cannot review are denied, and "
-            "repeated review failures fall back to your approval.\n\n"
+            f"uses {self._auto_classifier_model_label()}. Actions it cannot "
+            "review are denied, and repeated review failures fall back to your "
+            "approval.\n\n"
             "Changes here apply to this session only. Set "
             "`[models].auto_classifier` in config.toml for a persistent choice."
         )
@@ -19142,6 +19178,43 @@ class DeepAgentsApp(App):
             # removes the modal.
             self.call_after_refresh(start_selection_worker)
 
+        tail = ""
+        if self._auto_classifier_display_spec() is not None:
+            # The picker lists only recommended classifiers, so it offers no
+            # entry that reverts to the main agent model. `_auto_usage_text`
+            # carries the hint, but it is mounted only for an unrecognized
+            # `/auto` subcommand, so no path that opens this modal shows it.
+            tail = " Clear it with `/auto model clear`."
+
+        # Every branch hands the screen a `Content`: the description reaches a
+        # `Static`, which parses a plain `str` as markup. The branches naming a
+        # spec use `from_markup` with `$spec` per `AGENTS.md`, because the spec
+        # is user-supplied: `/auto model <spec>` validates, but the startup seed
+        # from `--auto-classifier-model` / `config.toml` does not. Interpolated
+        # into a plain `str` instead,
+        # a spec containing `[dim]` would render a truncated, dimmed name that is
+        # not the model reviewing actions, and one containing `[/]` would raise
+        # `MarkupError` when the modal opens. The first branch names no spec, so
+        # the plain `Content` constructor — which parses nothing — suffices.
+        active = self._auto_classifier_review_model_spec()
+        if active is None:
+            description = Content(
+                "Auto currently reviews with the main agent model." + tail
+            )
+        elif not self._auto_classifier_is_distinct():
+            # Not `display_spec() is None`: that asks where the spec came from,
+            # but the sentence claims the spec *is* the main agent model. They
+            # diverge when a configured classifier matches the main model, which
+            # `_notify_auto_classifier_active` also treats as "not distinct".
+            description = Content.from_markup(
+                "Auto currently reviews with $spec, the main agent model." + tail,
+                spec=active,
+            )
+        else:
+            description = Content.from_markup(
+                "Auto currently reviews with $spec." + tail, spec=active
+            )
+
         screen = ModelSelectorScreen(
             current_model=current_model,
             current_provider=current_provider,
@@ -19149,12 +19222,7 @@ class DeepAgentsApp(App):
             recommended_models=_AUTO_CLASSIFIER_RECOMMENDED_MODELS,
             include_recent_models=False,
             title="Choose the Auto classifier model",
-            description=(
-                "Recommended models favor lower latency and cost for repeated "
-                "reviews. A faster, cheaper model may review actions less "
-                "carefully. Clear it with `/auto model clear` to reuse the main "
-                "agent model."
-            ),
+            description=description,
         )
         self.push_screen(screen, handle_result)
 
@@ -20923,6 +20991,9 @@ class DeepAgentsApp(App):
                 )
                 await self._mount_message(AppMessage(resume_hint))
 
+            if resume_thread_id is not None:
+                await self._maybe_compact_after_resume()
+
             # Drain any messages the user typed after we cleared the queue
             # but before the new server was ready.
             if self._pending_messages and not self._agent_running:
@@ -24205,18 +24276,44 @@ class DeepAgentsApp(App):
         if target is None:
             return
 
-        active_agent = self._assistant_id or DEFAULT_ASSISTANT_ID
-        if target.agent_name == active_agent:
-            await self._resume_thread(target.thread_id)
-            return
-
         # This command runs inline on Textual's message pump. Detach before
-        # awaiting the confirmation modal so Enter/Esc can reach it.
+        # awaiting the cwd/compaction modals so Enter/Esc can reach them. Both
+        # continuations mount their own failure messages.
+        active_agent = self._assistant_id or DEFAULT_ASSISTANT_ID
         self._schedule_off_message_pump(
-            self._confirm_then_resume_cross_agent_thread(target),
+            self._resume_same_agent_thread(target.thread_id)
+            if target.agent_name == active_agent
+            else self._confirm_then_resume_cross_agent_thread(target),
             context=f"threads-resume:{target.thread_id}",
         )
 
+    async def _resume_same_agent_thread(self, thread_id: str) -> None:
+        """Resume a thread already owned by the active agent.
+
+        A thin reporting wrapper: `_resume_thread` handles its own failures once
+        the switch is under way, but its pre-switch phase (the cwd prompt, the
+        compaction prompt, and their modal setup) sits outside that boundary.
+        Detached continuations only get logged, so without this a `/threads -r`
+        would end with no visible outcome.
+
+        Args:
+            thread_id: The thread to resume on the current agent.
+
+        Raises:
+            asyncio.CancelledError: If app shutdown cancels the detached flow.
+        """
+        try:
+            await self._resume_thread(thread_id)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("Same-agent resume failed for thread %s", thread_id)
+            await self._mount_message(
+                ErrorMessage(
+                    f"Could not resume thread {thread_id}. Use /threads to try again."
+                )
+            )
+
     async def _resolve_threads_resume_target(
         self, requested_id: str | None
     ) -> _ThreadsResumeTarget | None:
@@ -24928,6 +25025,69 @@ class DeepAgentsApp(App):
             return False
         return bool(changes)
 
+    async def _restore_resumed_context_tokens(self) -> None:
+        """Seed `_context_tokens` from the checkpoint without loading history.
+
+        A launch that resumes *and* carries an initial prompt skips the history
+        load, so nothing would populate the context size — and that path is the
+        one where it matters most, since the prompt is submitted against the
+        full restored context moments later.
+        """
+        if not self._lc_thread_id or not self._agent:
+            return
+        try:
+            state_values = await self._get_thread_state_values(self._lc_thread_id)
+        except Exception:
+            logger.warning(
+                "Could not read the context size for resumed thread %s; "
+                "skipping the compaction suggestion",
+                self._lc_thread_id,
+                exc_info=True,
+            )
+            return
+        tokens = _persisted_context_tokens(state_values)
+        if tokens > 0:
+            self._on_tokens_update(tokens)
+
+    async def _maybe_compact_after_resume(self) -> None:
+        """Offer to compact a just-resumed thread with an oversized context.
+
+        Resuming costs nothing on its own, so the prompt runs once the thread is
+        live and before the user's next turn pays for the restored context.
+        Declining is free: `/compact` remains available for the rest of the
+        session.
+        """
+        from deepagents_code.config_manifest import (
+            COMPACT_ON_RESUME_THRESHOLD_DEFAULT,
+            get_option,
+            load_config_toml,
+            resolve_scalar,
+        )
+
+        threshold = COMPACT_ON_RESUME_THRESHOLD_DEFAULT
+        option = get_option("threads.compact_on_resume_threshold")
+        if option is not None:
+            resolved, _ = resolve_scalar(option, toml_data=load_config_toml())
+            if isinstance(resolved, int):
+                threshold = resolved
+        if threshold <= 0 or self._context_tokens <= threshold:
+            return
+
+        from deepagents_code.tui.modals.resume_compact import ResumeCompactPromptScreen
+
+        try:
+            compact = await self._push_screen_wait(
+                ResumeCompactPromptScreen(
+                    context_tokens=self._context_tokens,
+                    threshold=threshold,
+                )
+            )
+        except Exception:
+            logger.exception("Failed to show the compact-on-resume prompt")
+            return
+        if compact:
+            await self._handle_offload()
+
     async def _offer_thread_cwd_switch(
         self,
         thread_id: str,
@@ -25225,6 +25385,12 @@ class DeepAgentsApp(App):
             # or failed load leaves the hint under something else.
             await self._mount_previous_thread_hint(prev_session_thread)
 
+            # Landing on a new thread re-arms the same-thread toast, so stepping
+            # back to a thread and re-selecting it announces itself again.
+            self._last_thread_unchanged = None
+            if await self._run_session_start_hook(SessionStartCause.RESUME):
+                await self._maybe_compact_after_resume()
+
             # Deferred above so it lands last, keeping the interactive prompt
             # at the bottom of the transcript. Guarded because this runs inside
             # the rollback handler's `try`: failing to restore a review must
@@ -25233,12 +25399,6 @@ class DeepAgentsApp(App):
                 await self._remount_pending_goal_rubric_review()
             except Exception:
                 logger.exception("Failed to restore pending goal review")
-
-            # Landing on a new thread re-arms the same-thread toast, so stepping
-            # back to a thread and re-selecting it announces itself again.
-            self._last_thread_unchanged = None
-            if not await self._run_session_start_hook(SessionStartCause.RESUME):
-                return
         except Exception as exc:
             if prefetched_payload is None:
                 logger.exception("Failed to prefetch history for thread %s", thread_id)