deepagents-code 0.1.46__tar.gz → 0.1.47__tar.gz

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.47](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.46...deepagents-code==0.1.47) (2026-07-24)
+
+### Features
+
+- Added `yolo` mode to the `Shift+Tab` approval cycle ([#5035](https://github.com/langchain-ai/deepagents/issues/5035)).
+- Show the changelog link before prompting to update via the install script ([#5034](https://github.com/langchain-ai/deepagents/issues/5034)).
+
 ## [0.1.46](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.45...deepagents-code==0.1.46) (2026-07-24)
 
 ### Highlights

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.46
+Version: 0.1.47
 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/

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "efa86c5"
+BUILD_COMMIT = "8aa29dd"

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/_env_vars.py

@@ -401,6 +401,17 @@ THEME = "DEEPAGENTS_CODE_THEME"
 USER_ID = "DEEPAGENTS_CODE_USER_ID"
 """Attach a user identifier to LangSmith trace metadata."""
 
+YOLO_SWITCHER = "DEEPAGENTS_CODE_YOLO_SWITCHER"
+"""Include YOLO in the Shift+Tab approval-mode cycle.
+
+Enabled by default so an interactive session can cycle Manual → Auto → YOLO
+without restarting with `--yolo`. Set to a falsy value (`0`, `false`, `no`,
+`off`, or empty) to leave Shift+Tab limited to Manual/Auto. Also settable via
+`[startup].yolo_switcher` in config.toml so orgs can distribute the opt-out.
+Parsed by `classify_env_bool` through the config resolver (unrecognized values
+fall through rather than forcing the default).
+"""
+
 _TRUTHY_VALUES = frozenset({"1", "true", "yes", "on"})
 _FALSY_VALUES = frozenset({"0", "false", "no", "off", ""})
 

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/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.46"  # x-release-please-version
+__version__ = "0.1.47"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/app.py

@@ -3105,6 +3105,7 @@ class DeepAgentsApp(App):
             self._auto_approve = False
         self._approval_mode_blocked = False
         self._auto_mode_notice_pending = False
+        self._yolo_mode_notice_pending = False
 
         if sub_title is None and self._sandbox_type is not None:
             display = _SANDBOX_DISPLAY_NAMES.get(
@@ -16912,10 +16913,12 @@ class DeepAgentsApp(App):
             panel.toggle()
 
     async def action_toggle_auto_approve(self) -> None:
-        """Toggle between Manual and Auto after Store acknowledgement.
+        """Cycle Manual → Auto → YOLO (when enabled) after Store acknowledgement.
 
-        A session launched in YOLO moves to Manual; normal key navigation never
-        enters unrestricted mode.
+        YOLO is included by default (`startup.yolo_switcher` / env). Auto is
+        skipped when a sandbox makes classifier-backed Auto ineligible. The
+        first Shift+Tab into YOLO prompts for the same install-local
+        acknowledgement used by `--yolo` before unrestricted mode becomes active.
         """
         from deepagents_code.tui.modals.plugin_manager import PluginManagerScreen
         from deepagents_code.tui.widgets.agent_selector import AgentSelectorScreen
@@ -16969,17 +16972,47 @@ class DeepAgentsApp(App):
         if self._pending_ask_user_widget is not None:
             self._pending_ask_user_widget.action_previous_question()
             return
-        from deepagents_code.approval_mode import ApprovalMode
+        from deepagents_code.approval_mode import (
+            ApprovalMode,
+            has_yolo_acknowledgement,
+            next_approval_mode,
+        )
+        from deepagents_code.config import is_yolo_switcher_enabled
 
-        if self._approval_mode is ApprovalMode.MANUAL:
-            if not self._auto_mode_eligible:
-                self._warn_live_approval_mode_unavailable(
-                    "Auto is unavailable with a sandbox."
-                )
-                return
-            target = ApprovalMode.AUTO
-        else:
-            target = ApprovalMode.MANUAL
+        yolo_switcher_enabled = is_yolo_switcher_enabled()
+        target = next_approval_mode(
+            self._approval_mode,
+            auto_eligible=self._auto_mode_eligible,
+            yolo_switcher_enabled=yolo_switcher_enabled,
+        )
+        if target is None:
+            # `next_approval_mode` returns None only from Manual when neither
+            # Auto (sandbox-ineligible) nor the YOLO switcher entry is available,
+            # so this is the only reachable case.
+            self._warn_live_approval_mode_unavailable(
+                "Auto is unavailable with a sandbox, and YOLO is disabled "
+                "in the approval switcher."
+            )
+            return
+
+        # Gate the first YOLO switcher entry on the same policy acknowledgement
+        # as `--yolo`. Do not activate YOLO until the user continues.
+        if target is ApprovalMode.YOLO and not has_yolo_acknowledgement():
+            self._prompt_yolo_switcher_acknowledgement()
+            return
+
+        await self._set_approval_mode(target)
+
+    async def _set_approval_mode(self, target: ApprovalMode) -> bool:
+        """Apply an approval-mode change after optional live Store acknowledgement.
+
+        Args:
+            target: Mode to select.
+
+        Returns:
+            `True` when local UI state was updated to `target`.
+        """
+        from deepagents_code.approval_mode import ApprovalMode
 
         # With no usable agent/session pair there is no running graph to update.
         # Stage the selection locally; `execute_task_textual` persists it before
@@ -16993,7 +17026,12 @@ class DeepAgentsApp(App):
                 self._warn_live_approval_mode_unavailable(
                     "Auto could not be persisted; remaining in Manual."
                 )
-                return
+                return False
+            if target is ApprovalMode.YOLO:
+                self._warn_live_approval_mode_unavailable(
+                    "YOLO could not be persisted; remaining in the previous mode."
+                )
+                return False
             self._approval_mode_blocked = True
             self._warn_live_approval_mode_unavailable(
                 "Manual could not be persisted; active work was cancelled and "
@@ -17001,7 +17039,7 @@ class DeepAgentsApp(App):
             )
             if self._agent_running:
                 self._force_interrupt_active_work()
-            return
+            return False
 
         self._approval_mode_blocked = False
         self._approval_mode = target
@@ -17014,6 +17052,73 @@ class DeepAgentsApp(App):
             self._notify_auto_mode_enabled_once()
             if should_persist_live:
                 await self._auto_accept_pending_goal_rubric()
+        elif target is ApprovalMode.YOLO:
+            # Warn before the await below. State is already committed above, so
+            # if goal-rubric auto-accept raises, YOLO is active and the "no
+            # review" warning must have fired first. AUTO notifies before its
+            # await for the same reason.
+            self.notify(
+                "YOLO is active: gated actions run without review.",
+                severity="warning",
+                timeout=8,
+                markup=False,
+            )
+            if should_persist_live:
+                await self._auto_accept_pending_goal_rubric()
+        return True
+
+    def _prompt_yolo_switcher_acknowledgement(self) -> None:
+        """Show the first-run YOLO acknowledgement before entering unrestricted mode.
+
+        YOLO stays inactive until Enter persists the acknowledgement and the
+        follow-up mode write succeeds. Esc (or a non-true dismiss) leaves the
+        current mode untouched and does not store the acknowledgement.
+        """
+        from deepagents_code.approval_mode import (
+            ApprovalMode,
+            save_yolo_acknowledgement,
+        )
+        from deepagents_code.tui.widgets.yolo_mode_notice import YoloModeNoticeScreen
+
+        if getattr(self, "_yolo_mode_notice_pending", False):
+            return
+
+        def handle_result(accepted: bool | None) -> None:
+            self._yolo_mode_notice_pending = False
+            if accepted is not True:
+                self.notify(
+                    "Stayed in the current approval mode.",
+                    severity="information",
+                    markup=False,
+                )
+                return
+            if not save_yolo_acknowledgement():
+                self._warn_live_approval_mode_unavailable(
+                    "YOLO acknowledgement could not be saved; staying in the "
+                    "current mode."
+                )
+                return
+            task = asyncio.create_task(self._set_approval_mode(ApprovalMode.YOLO))
+            task.add_done_callback(_log_task_exception)
+
+        try:
+            self.push_screen(YoloModeNoticeScreen(), handle_result)
+        except Exception:
+            # This modal *is* the YOLO gate (unlike Auto's post-hoc notice), so
+            # a failed push leaves the mode unchanged. Surface it, or Shift+Tab
+            # looks dead. Leaving `_yolo_mode_notice_pending` unset (it is set
+            # only below, after a successful push) lets a later Shift+Tab retry.
+            logger.warning(
+                "Could not show YOLO switcher acknowledgement", exc_info=True
+            )
+            self._warn_live_approval_mode_unavailable(
+                "Could not open the YOLO confirmation; approval mode unchanged."
+            )
+            return
+
+        # Mark pending only after the push succeeds so a failed push cannot
+        # suppress a later try for the whole session.
+        self._yolo_mode_notice_pending = True
 
     def action_toggle_tool_output(self) -> None:
         """Toggle the most recent collapsible transcript unit."""

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/approval_mode.py

@@ -63,6 +63,46 @@ def coerce_approval_mode(value: object) -> ApprovalMode:
         return ApprovalMode.MANUAL
 
 
+def next_approval_mode(
+    current: ApprovalMode | str | object,
+    *,
+    auto_eligible: bool,
+    yolo_switcher_enabled: bool,
+) -> ApprovalMode | None:
+    """Return the next Shift+Tab approval mode for the active session.
+
+    The cycle is Manual → Auto → YOLO → Manual when both Auto and the YOLO
+    switcher entry are available. Auto is omitted when `auto_eligible` is false
+    (for example a remote sandbox). YOLO is omitted when orgs/users disable
+    `startup.yolo_switcher`. Launching with `--yolo` still leaves unrestricted
+    mode when the switcher entry is disabled; Shift+Tab only exits YOLO then.
+
+    Args:
+        current: Active approval mode (mode enum or raw value).
+        auto_eligible: Whether classifier-backed Auto can be selected.
+        yolo_switcher_enabled: Whether unrestricted YOLO appears in the cycle.
+
+    Returns:
+        The next mode, or `None` when no alternate mode is available.
+    """
+    mode = (
+        current if isinstance(current, ApprovalMode) else coerce_approval_mode(current)
+    )
+    if mode is ApprovalMode.MANUAL:
+        if auto_eligible:
+            return ApprovalMode.AUTO
+        if yolo_switcher_enabled:
+            return ApprovalMode.YOLO
+        return None
+    if mode is ApprovalMode.AUTO:
+        if yolo_switcher_enabled:
+            return ApprovalMode.YOLO
+        return ApprovalMode.MANUAL
+    # Only genuine YOLO reaches here; unknown/invalid values were normalized to
+    # Manual above and took that branch. Exiting YOLO always returns to Manual.
+    return ApprovalMode.MANUAL
+
+
 def approval_mode_key(thread_id: str) -> str:
     """Return the store key for a thread's live approval mode.
 

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/config.py

@@ -3255,6 +3255,27 @@ def is_memory_auto_save_enabled() -> bool:
     return bool(value)
 
 
+def is_yolo_switcher_enabled() -> bool:
+    """Return whether Shift+Tab may enter unrestricted YOLO mode.
+
+    Resolves the `startup.yolo_switcher` option from env/`config.toml`,
+    defaulting to enabled. When disabled, the interactive cycle stays Manual /
+    Auto only (or Manual alone when Auto is ineligible). Sessions already in
+    YOLO (for example via `--yolo`) can still leave it with Shift+Tab.
+    """
+    from deepagents_code.config_manifest import (
+        get_option,
+        load_config_toml,
+        resolve_scalar,
+    )
+
+    option = get_option("startup.yolo_switcher")
+    if option is None:
+        return True
+    value, _ = resolve_scalar(option, toml_data=load_config_toml())
+    return bool(value)
+
+
 def is_openai_prompt_cache_key_enabled() -> bool:
     """Return whether OpenAI model calls should carry a per-thread cache key.
 

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/config_manifest.py

@@ -1464,6 +1464,19 @@ _STATIC_OPTIONS: tuple[ConfigOption, ...] = (
         toml_keys=("startup", "mode"),
         cli_flag="--auto-approve",
     ),
+    ConfigOption(
+        key="startup.yolo_switcher",
+        group="Startup",
+        summary=(
+            "Include YOLO in the Shift+Tab approval-mode cycle "
+            "(Manual → Auto → YOLO); disable to keep the cycle Manual/Auto only."
+        ),
+        kind=OptionKind.BOOL,
+        default=True,
+        env_var=_env_vars.YOLO_SWITCHER,
+        empty_env_is_false=True,
+        toml_keys=("startup", "yolo_switcher"),
+    ),
     # --- Debug / Development -------------------------------------------
     ConfigOption(
         key="debug.enabled",

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/tui/widgets/startup_tip.py

@@ -10,6 +10,12 @@ from textual.widgets import Static
 
 from deepagents_code._env_vars import HIDE_SPLASH_TIPS, is_env_truthy
 
+_TIP_SHIFT_TAB_WITH_YOLO = "Press Shift+Tab to cycle Manual, Auto, and YOLO modes"
+"""Tip used when `startup.yolo_switcher` keeps YOLO in the approval cycle."""
+
+_TIP_SHIFT_TAB_WITHOUT_YOLO = "Press Shift+Tab to toggle Manual and Auto modes"
+"""Tip used when orgs/users disable YOLO entry via the approval switcher."""
+
 _TIPS: dict[str, int] = {
     "Use @ to reference files and / for commands": 3,
     "Try /threads to resume a previous conversation": 2,
@@ -27,12 +33,16 @@ _TIPS: dict[str, int] = {
     "Ask for a workflow to fan work out to subagents in parallel": 3,
     "Use /timestamps to show or hide message timestamp footers": 1,
     "Use /agents to browse and switch between your available agents": 2,
-    "Press Shift+Tab to toggle Manual and Auto modes": 2,
+    _TIP_SHIFT_TAB_WITH_YOLO: 2,
     "Use !! for incognito shell commands that stay out of model context": 1,
     "Deep Agents can explain its own features and look up its docs. Ask it how to use.": 3,  # noqa: E501
 }
 """Tips shown above the chat input. One is chosen at random per launch,
-weighted by these relative selection weights."""
+weighted by these relative selection weights.
+
+The Shift+Tab tip is varied at pick time via `_active_tips` so disabled-YOLO
+installs do not advertise a switcher path that policy has removed.
+"""
 
 # Fail fast at import if the registry is ever emptied or given a non-positive
 # weight: `random.choices` would otherwise raise a cryptic error at widget
@@ -46,15 +56,45 @@ if any(weight <= 0 for weight in _TIPS.values()):
     raise ValueError(msg)
 
 
-def _pick_tip() -> str:
+def _active_tips(*, yolo_switcher_enabled: bool | None = None) -> dict[str, int]:
+    """Return the weighted tip registry for the current switcher policy.
+
+    Args:
+        yolo_switcher_enabled: Override for whether YOLO appears in the
+            Shift+Tab cycle. When omitted, resolves `startup.yolo_switcher`.
+
+    Returns:
+        Weighted tip map appropriate for the active YOLO switcher setting.
+    """
+    if yolo_switcher_enabled is None:
+        from deepagents_code.config import is_yolo_switcher_enabled
+
+        yolo_switcher_enabled = is_yolo_switcher_enabled()
+
+    tips = dict(_TIPS)
+    if yolo_switcher_enabled:
+        return tips
+
+    # Replace the YOLO cycle tip with the Manual/Auto-only wording so the
+    # splash never claims Shift+Tab can enter unrestricted mode when policy
+    # has removed that entry from the switcher.
+    weight = tips.pop(_TIP_SHIFT_TAB_WITH_YOLO, None)
+    if weight is not None:
+        tips[_TIP_SHIFT_TAB_WITHOUT_YOLO] = weight
+    return tips
+
+
+def _pick_tip(*, yolo_switcher_enabled: bool | None = None) -> str:
     """Pick one startup tip using the configured relative weights.
 
+    Args:
+        yolo_switcher_enabled: Optional override forwarded to `_active_tips`.
+
     Returns:
-        Tip text selected from `_TIPS`.
+        Tip text selected from the active tip registry.
     """
-    tips = list(_TIPS.keys())
-    weights = list(_TIPS.values())
-    return random.choices(tips, weights=weights, k=1)[0]  # noqa: S311
+    tips = _active_tips(yolo_switcher_enabled=yolo_switcher_enabled)
+    return random.choices(list(tips.keys()), weights=list(tips.values()), k=1)[0]  # noqa: S311
 
 
 def show_startup_tip() -> bool:

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/deepagents_code/tui/widgets/welcome.py

@@ -117,7 +117,7 @@ def _debug_tag_style(*, ansi: bool, colors: theme.ThemeColors) -> str | TStyle:
 
 
 def _experimental_tag_style(*, ansi: bool, colors: theme.ThemeColors) -> str | TStyle:
-    """Build the style for the `(experimental mode)` tag.
+    """Build the style for the `(experimental)` tag.
 
     Args:
         ansi: Whether the active theme is an ANSI terminal theme.
@@ -162,7 +162,7 @@ class WelcomeBanner(Static):
 
     Renders a bordered box with the product title and optional version. A
     `(debug enabled)` tag appears when `DEEPAGENTS_CODE_DEBUG` is enabled
-    (truthy), and an `(experimental mode)` tag appears when
+    (truthy), and an `(experimental)` tag appears when
     `DEEPAGENTS_CODE_EXPERIMENTAL` is enabled (truthy), both even when the
     version is hidden. A `(local)` tag appears for
     editable installs only when the version is shown. Rows follow that appear
@@ -372,7 +372,7 @@ class WelcomeBanner(Static):
 
         Returns:
             Content with the title, optional version, and any applicable header
-            tags (`(debug enabled)` when debug is on; `(experimental mode)` when
+            tags (`(debug enabled)` when debug is on; `(experimental)` when
             experimental mode is on; `(local)` for editable
             installs when the version is shown), followed by any applicable rows
             in order: model (when `SPLASH_SHOW_MODEL`), directory (when
@@ -406,7 +406,7 @@ class WelcomeBanner(Static):
         if self._experimental_enabled:
             parts.append(
                 (
-                    " (experimental mode)",
+                    " (experimental)",
                     _experimental_tag_style(ansi=ansi, colors=colors),
                 )
             )

deepagents_code-0.1.47/deepagents_code/tui/widgets/yolo_mode_notice.py

@@ -0,0 +1,161 @@
+"""First-enable confirmation modal before Shift+Tab enters YOLO.
+
+Shown when the user cycles into unrestricted YOLO without a persisted
+acknowledgement. Enter acknowledges YOLO and records the policy version; Esc
+keeps the previous approval mode and leaves the acknowledgement unsaved.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Markdown, Static
+
+from deepagents_code.tui.widgets._links import open_checked_url_async
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+YOLO_MODE_DOCS_URL = (
+    "https://docs.langchain.com/oss/python/deepagents/code/approval-modes"
+)
+"""Canonical docs page for Manual / Auto / YOLO behavior."""
+
+YOLO_MODE_NOTICE_BODY = (
+    "You are about to enable **YOLO**. The agent will run **gated actions "
+    "without asking first** — shell commands, file edits, network calls, and "
+    "other tools on this machine.\n\n"
+    "This is **not Auto**. There is **no classifier review** and **no approval "
+    "prompt** while YOLO is active. Prefer Auto unless you intend full "
+    "unrestricted execution.\n\n"
+    "This notice appears **once** on this machine after you continue. You can "
+    "leave YOLO any time with **Shift+Tab**.\n\n"
+    f"[Learn more about approval modes]({YOLO_MODE_DOCS_URL})"
+)
+"""Default Markdown body shown before the first YOLO switcher enable."""
+
+
+class YoloModeNoticeScreen(ModalScreen[bool]):
+    """In-TUI acknowledgement shown before unrestricted YOLO becomes active.
+
+    Dismisses with `True` on Enter (acknowledge and enable) and `False` on Esc
+    (keep the previous mode). Programmatic dismiss may yield `None`; callers
+    treat that like cancel so YOLO is never left active without an explicit
+    acknowledge.
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("enter", "confirm", "Enable YOLO", show=False, priority=True),
+        Binding("escape", "cancel", "Keep previous", show=False, priority=True),
+    ]
+
+    CSS = """
+    YoloModeNoticeScreen {
+        align: center middle;
+    }
+
+    YoloModeNoticeScreen > Vertical {
+        width: 72;
+        max-width: 90%;
+        height: auto;
+        background: $surface;
+        border: solid $error;
+        padding: 1 2;
+    }
+
+    YoloModeNoticeScreen .yolo-mode-notice-title {
+        text-style: bold;
+        color: $error;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    YoloModeNoticeScreen .yolo-mode-notice-body {
+        height: auto;
+        color: $text;
+        margin-bottom: 1;
+        padding: 0;
+    }
+
+    YoloModeNoticeScreen .yolo-mode-notice-body > * {
+        margin: 0 0 1 0;
+    }
+
+    YoloModeNoticeScreen .yolo-mode-notice-body > *:last-child {
+        margin-bottom: 0;
+    }
+
+    YoloModeNoticeScreen .yolo-mode-notice-help {
+        height: 1;
+        color: $text-muted;
+        text-style: italic;
+        text-align: center;
+        margin-top: 1;
+    }
+    """
+
+    # The screen must be the focus target for its own priority Enter binding to
+    # fire (see `on_mount`). Esc does not depend on focus: the app owns a global
+    # priority `escape` binding that routes to `action_cancel` for active modals.
+    can_focus = True
+
+    def __init__(self, body: str | None = None) -> None:
+        """Initialize the notice.
+
+        Args:
+            body: Optional Markdown body under the title. Defaults to
+                `YOLO_MODE_NOTICE_BODY`. Links open in a browser.
+        """
+        super().__init__()
+        self._body = YOLO_MODE_NOTICE_BODY if body is None else body
+
+    def on_mount(self) -> None:
+        """Take focus so priority bindings receive Enter/Esc."""
+        self.focus()
+
+    def compose(self) -> ComposeResult:
+        """Compose the YOLO acknowledgement notice.
+
+        Yields:
+            Title, body, and help-row widgets parented inside a `Vertical`.
+        """
+        with Vertical():
+            yield Static(
+                "YOLO mode",
+                classes="yolo-mode-notice-title",
+                markup=False,
+            )
+            # open_links=False so we own the click path (toast feedback + shared
+            # URL safety). Assistant message widgets use the same pattern.
+            yield Markdown(
+                self._body,
+                classes="yolo-mode-notice-body",
+                open_links=False,
+            )
+            yield Static(
+                "Enter to acknowledge and enable YOLO · Esc to keep current mode",
+                classes="yolo-mode-notice-help",
+                markup=False,
+            )
+
+    async def on_markdown_link_clicked(self, event: Markdown.LinkClicked) -> None:
+        """Open docs (or any body link) with the shared URL helper."""
+        event.stop()
+        await open_checked_url_async(event.href, app=self.app, notify_on_success=True)
+
+    def action_confirm(self) -> None:
+        """Acknowledge YOLO and mark the notice dismissed without re-showing."""
+        self.dismiss(True)
+
+    def action_cancel(self) -> None:
+        """Keep the previous approval mode without persisting acknowledgement.
+
+        The method name must stay `cancel`: the app owns a priority `escape`
+        binding that, for an active `ModalScreen`, dispatches to
+        `action_cancel` if present and otherwise falls through to
+        `dismiss(None)`. Renaming this would silently regress Esc handling.
+        """
+        self.dismiss(False)

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deepagents-code"
-version = "0.1.46"
+version = "0.1.47"
 description = "Terminal coding agent built on the Deep Agents SDK - works with any model, with persistent memory, customizable skills, subagents, and approval controls."
 readme = "README.md"
 license = { text = "MIT" }

{deepagents_code-0.1.46 → deepagents_code-0.1.47}/scripts/install.sh

@@ -833,6 +833,12 @@ esac
 # tell whether an existing install is out of date before upgrading it.
 PYPI_JSON_URL="https://pypi.org/pypi/deepagents-code/json"
 
+# Base URL for a version-specific GitHub release, surfaced before the update
+# prompt so users can review what changed before agreeing to upgrade. Release
+# tags are `deepagents-code==X.Y.Z`; the `==` must be percent-encoded (%3D%3D)
+# for the tag URL to resolve.
+RELEASE_TAG_URL_BASE="https://github.com/langchain-ai/deepagents/releases/tag/deepagents-code%3D%3D"
+
 # Validate and normalize extras: accept bare CSV, wrap in brackets for pip
 if [[ -n "$EXTRAS" ]]; then
   # Strip brackets if the user passed them anyway
@@ -1257,6 +1263,7 @@ elif [ -n "$PRE_VERSION" ] && [ -z "$VERSION" ] && [ -z "$PRERELEASE_REQUESTED"
   elif [ "$ASSUME_YES" = "1" ]; then
     log_info "Updating deepagents-code ${PRE_VERSION} → ${LATEST_VERSION}..."
   elif can_prompt; then
+    log_info "What's new: ${RELEASE_TAG_URL_BASE}${LATEST_VERSION}"
     if prompt_yn "Update deepagents-code ${PRE_VERSION} → ${LATEST_VERSION}?"; then
       log_info "Updating deepagents-code ${PRE_VERSION} → ${LATEST_VERSION}..."
     else