deepagents-code 0.1.25__tar.gz → 0.1.26__tar.gz

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.26](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.25...deepagents-code==0.1.26) (2026-06-26)
+
+### Bug Fixes
+
+* Pin app version when installing extras ([#4313](https://github.com/langchain-ai/deepagents/issues/4313)) ([c20c8e2](https://github.com/langchain-ai/deepagents/commit/c20c8e2fc138f72f1444107d2a936305a591807b))
+
 ## [0.1.25](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.24...deepagents-code==0.1.25) (2026-06-26)
 
 ### Bug Fixes

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.25
+Version: 0.1.26
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -45,6 +45,7 @@ Requires-Dist: mcp<2.0.0,>=1.9.2
 Requires-Dist: packaging>=26.2
 Requires-Dist: pillow<13.0.0,>=12.2.0
 Requires-Dist: prompt-toolkit<4.0.0,>=3.0.52
+Requires-Dist: pydantic<2.14.0a0,>=2.7.4
 Requires-Dist: pyperclip<2.0.0,>=1.11.0
 Requires-Dist: python-dotenv<2.0.0,>=1.2.2
 Requires-Dist: pyyaml>=6.0.3

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "9f2622d"
+BUILD_COMMIT = "de6e341"

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

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/deepagents_code/update_check.py

@@ -2123,6 +2123,7 @@ def _uv_tool_install_command(
     Raises:
         ExtrasIntrospectionError: If a metadata-sourced extra name fails PEP 508
             validation.
+        ValueError: If `version` is not PEP 440 compliant.
 
     Propagates `ToolRequirementIntrospectionError` if the uv tool receipt's
     interpreter or `--with` packages cannot be determined safely from the tool
@@ -2138,6 +2139,8 @@ def _uv_tool_install_command(
     try:
         requirement = _dcode_extras_requirement(extras, version=version)
     except ValueError as exc:
+        if str(exc).startswith("Invalid deepagents-code version"):
+            raise
         msg = f"Distribution metadata yielded an invalid extra name: {exc}"
         raise ExtrasIntrospectionError(msg) from exc
     cmd = "uv tool install --reinstall -U" if reinstall else "uv tool install -U"
@@ -2298,13 +2301,13 @@ def install_package_command(
 
     Delegates to `_uv_tool_install_command` (the same builder the extras path
     uses), passing the new package as a `--with` requirement. That builder folds
-    already-installed extras into the `deepagents-code[...]` requirement, and
-    preserves the uv-managed Python interpreter, the receipt's existing `--with`
-    packages, and the installed pre-release channel. Without this, reinstalling
-    to add a second package would replace the tool with a plain `deepagents-code`
-    (dropping extras the user added through `/install <extra>`), rebuild with
-    only the newest `--with` package (dropping previously configured custom
-    providers), or silently downgrade a pre-release install to the latest stable.
+    already-installed extras into the pinned `deepagents-code[...]` requirement,
+    and preserves the uv-managed Python interpreter and the receipt's existing
+    `--with` packages. Without this, reinstalling to add a second package would
+    replace the tool with a plain `deepagents-code` (dropping extras the user
+    added through `/install <extra>`), rebuild with only the newest `--with`
+    package (dropping previously configured custom providers), or silently
+    downgrade when the latest stable app depends on prerelease packages.
 
     Like the extras path (`_install_extra_uv_tool_command`), passes
     `reinstall=True` so the upgrade rebuilds the tool environment cleanly; see
@@ -2335,8 +2338,8 @@ def install_package_command(
         )
         raise ValueError(msg)
     return _uv_tool_install_command(
-        version=None,
-        include_prereleases=None,
+        version=__version__,
+        include_prereleases=True,
         distribution_name=distribution_name,
         with_packages_to_add=(package,),
         reinstall=True,
@@ -2434,6 +2437,8 @@ def _install_extra_uv_tool_command(
 ) -> str:
     """Return the receipt-preserving uv command that installs one dcode extra.
 
+    Pins the running `deepagents-code` version and allows prerelease dependency
+    resolution so adding an extra cannot make uv backtrack to an older app release.
     Passes `reinstall=True` so the upgrade rebuilds the tool environment from
     scratch rather than patching it in place; see `_uv_tool_install_command`'s
     `reinstall` parameter for why an in-place upgrade is unsafe.
@@ -2459,8 +2464,8 @@ def _install_extra_uv_tool_command(
         )
         raise ValueError(msg)
     return _uv_tool_install_command(
-        version=None,
-        include_prereleases=None,
+        version=__version__,
+        include_prereleases=True,
         distribution_name=distribution_name,
         extras_to_add=(extra,),
         reinstall=True,
@@ -2504,11 +2509,11 @@ async def perform_install_extra(
 ) -> tuple[bool, str]:
     """Add `extra` to the installed dcode tool environment.
 
-    Runs `uv tool install --reinstall -U 'deepagents-code[<extras>]'`,
-    preserving any extras that are already installed. Editable installs are
-    refused — the caller should rerun their `uv tool install --editable` command
-    with `--with 'deepagents-code[<extra>]'` added so the extra is resolved
-    against the editable source.
+    Runs `uv tool install --reinstall -U 'deepagents-code[<extras>]==<current>'
+    --prerelease allow`, preserving any extras that are already installed.
+    Editable installs are refused — the caller should rerun their
+    `uv tool install --editable` command with `--with 'deepagents-code[<extra>]'`
+    added so the extra is resolved against the editable source.
 
     Args:
         extra: The extra name to install. Must satisfy `is_valid_extra_name`;
@@ -2575,10 +2580,11 @@ async def perform_install_package(
 ) -> tuple[bool, str]:
     """Add an arbitrary `package` to the installed dcode tool environment.
 
-    Runs `uv tool install --reinstall -U 'deepagents-code[<extras>]' --with
-    <package>`, the escape hatch for a provider whose package is not a
-    `deepagents-code` extra (e.g. a custom or in-house `class_path` model).
-    Already-installed extras are preserved so the reinstall does not drop them.
+    Runs `uv tool install --reinstall -U 'deepagents-code[<extras>]==<current>'
+    --with <package> --prerelease allow`, the escape hatch for a provider whose
+    package is not a `deepagents-code` extra (e.g. a custom or in-house
+    `class_path` model). Already-installed extras are preserved so the reinstall
+    does not drop them.
     Editable installs are refused
     — the caller should rerun their `uv tool install --editable` command with
     `--with <package>` added so it resolves against the editable source.

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deepagents-code"
-version = "0.1.25"
+version = "0.1.26"
 description = "Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities."
 readme = "README.md"
 license = { text = "MIT" }
@@ -40,6 +40,7 @@ dependencies = [
     "langchain-anthropic>=1.4.7,<2.0.0",
     "langchain-google-genai>=4.2.5,<5.0.0",
     "langchain-openai>=1.3.3,<2.0.0",
+    "pydantic>=2.7.4,<2.14.0a0",
 
     # UI/Terminal
     # Workaround for Textualize/textual#6378 lives in `_textual_patches.py`.

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/scripts/install.sh

@@ -7,11 +7,14 @@
 # Install an exact pre-release version:
 #   curl -LsSf https://langch.in/dcode | DEEPAGENTS_CODE_VERSION="0.1.0rc1" bash
 #
-# Allow uv to consider alpha/beta/rc releases when resolving the latest version:
+# Override uv's pre-release strategy when resolving the latest version:
 #   curl -LsSf https://langch.in/dcode | DEEPAGENTS_CODE_PRERELEASE="allow" bash
 #
-# DEEPAGENTS_CODE_VERSION and DEEPAGENTS_CODE_PRERELEASE are mutually exclusive:
-# an exact pin already selects a single version, so setting both is an error.
+# By default, the installer uses uv's `allow` pre-release strategy so stable
+# deepagents-code releases that pin a pre-release dependency can resolve.
+# DEEPAGENTS_CODE_VERSION and an explicit DEEPAGENTS_CODE_PRERELEASE are mutually
+# exclusive: an exact pin already selects a single version, so setting both is an
+# error.
 #
 # Already installed?
 #   Safe to re-run. If a newer version exists, it asks before upgrading — or
@@ -47,8 +50,8 @@
 #     (mutually exclusive with DEEPAGENTS_CODE_PRERELEASE)
 #   DEEPAGENTS_CODE_PRERELEASE — uv pre-release strategy applied when
 #     resolving the latest version: disallow, allow, if-necessary, explicit,
-#     or if-necessary-or-explicit (mutually exclusive with
-#     DEEPAGENTS_CODE_VERSION)
+#     or if-necessary-or-explicit (default: allow; explicitly setting it is
+#     mutually exclusive with DEEPAGENTS_CODE_VERSION)
 #   DEEPAGENTS_CODE_PYTHON — Python version to use (default: 3.13)
 #   DEEPAGENTS_CODE_YES — set to 1 to accept an available update without
 #     prompting (assume "yes"). Exists so automated runs that still attach a
@@ -341,7 +344,8 @@ copy_install_log() {
 # ---------------------------------------------------------------------------
 EXTRAS="${DEEPAGENTS_CODE_EXTRAS:-}"
 VERSION="${DEEPAGENTS_CODE_VERSION:-}"
-PRERELEASE="${DEEPAGENTS_CODE_PRERELEASE:-}"
+PRERELEASE_REQUESTED="${DEEPAGENTS_CODE_PRERELEASE:-}"
+PRERELEASE="${PRERELEASE_REQUESTED:-allow}"
 PYTHON_REQUESTED=false
 if [[ -n "${DEEPAGENTS_CODE_PYTHON:-}" ]]; then
   PYTHON_REQUESTED=true
@@ -383,11 +387,12 @@ if [[ -n "$EXTRAS" ]]; then
   EXTRAS="[${EXTRAS}]"
 fi
 
-# An exact pin already selects a single version, so a pre-release strategy
-# (which only affects how a range resolves) is redundant at best and
-# contradictory at worst (e.g. an rc pin with "disallow"). Reject the combo
-# up front rather than forwarding an ambiguous request to uv.
-if [[ -n "$VERSION" && -n "$PRERELEASE" ]]; then
+# An exact pin already selects a single version, so an explicitly requested
+# pre-release strategy (which only affects how a range resolves) is redundant at
+# best and contradictory at worst (e.g. an rc pin with "disallow"). Reject only
+# user-provided combinations; the installer's default `if-necessary` strategy is
+# not forwarded when a version is pinned.
+if [[ -n "$VERSION" && -n "$PRERELEASE_REQUESTED" ]]; then
   log_error "DEEPAGENTS_CODE_VERSION and DEEPAGENTS_CODE_PRERELEASE are mutually exclusive."
   log_error "Pin an exact version, or set a pre-release strategy — not both."
   exit 1
@@ -453,29 +458,54 @@ install_uv() {
   fi
 }
 
-if ! command -v uv >/dev/null 2>&1; then
-  log_info "uv not found — installing..."
-  install_uv
-  fix_owner "${HOME}/.local/bin"  # root installs: restore user ownership
-fi
+# Resolve uv binary: honor UV_BIN override, then PATH, the env file written by
+# uv's installer, then the default install location (~/.local/bin). MDM and cron
+# jobs often run with a minimal PATH, so an existing uv in ~/.local/bin must
+# count as installed before we invoke the upstream installer.
+resolve_uv_bin() {
+  if [ -n "${UV_BIN:-}" ]; then
+    case "$UV_BIN" in
+      */*) [ -f "$UV_BIN" ] && [ -x "$UV_BIN" ] ;;
+      *)   command -v "$UV_BIN" >/dev/null 2>&1 ;;
+    esac
+    return $?
+  fi
 
-# Resolve uv binary: honor UV_BIN override, then PATH, then the default
-# install location (~/.local/bin). A fresh install may not have updated PATH
-# in the current session, so we source the env file the installer creates.
-if [ -z "${UV_BIN:-}" ]; then
-  UV_BIN="uv"
-  if ! command -v "$UV_BIN" >/dev/null 2>&1; then
-    if [ -f "${HOME}/.local/bin/env" ]; then
-      # shellcheck source=/dev/null
-      . "${HOME}/.local/bin/env"
+  if command -v uv >/dev/null 2>&1; then
+    UV_BIN="uv"
+    return 0
+  fi
+
+  if [ -f "${HOME}/.local/bin/env" ]; then
+    set +e +u
+    # shellcheck source=/dev/null
+    . "${HOME}/.local/bin/env"
+    set -e -u
+    if command -v uv >/dev/null 2>&1; then
+      UV_BIN="uv"
+      return 0
     fi
   fi
-  if ! command -v uv >/dev/null 2>&1; then
+
+  if [ -x "${HOME}/.local/bin/uv" ]; then
     UV_BIN="${HOME}/.local/bin/uv"
-    if [ ! -x "$UV_BIN" ]; then
-      log_error "uv not found after installation. Restart your shell or add ~/.local/bin to PATH."
-      exit 1
-    fi
+    return 0
+  fi
+
+  return 1
+}
+
+if ! resolve_uv_bin; then
+  if [ -n "${UV_BIN:-}" ]; then
+    log_error "UV_BIN is set but does not point to an executable uv: ${UV_BIN}"
+    exit 1
+  fi
+  log_info "uv not found — installing..."
+  install_uv
+  fix_owner "${HOME}/.local/bin"  # root installs: restore user ownership
+  if ! resolve_uv_bin; then
+    log_error "uv not found after installation. Restart your shell or add ~/.local/bin to PATH."
+    exit 1
   fi
 fi
 
@@ -555,7 +585,7 @@ if [ "$IS_EDITABLE" = true ]; then
     log_info "deepagents-code ${pre_label} found (editable install from local source)."
   fi
   log_info "  Replacing with a standard install from PyPI — the existing environment will be rebuilt."
-elif [ -n "$PRE_VERSION" ] && [ -z "$VERSION" ] && [ -z "$PRERELEASE" ]; then
+elif [ -n "$PRE_VERSION" ] && [ -z "$VERSION" ] && [ -z "$PRERELEASE_REQUESTED" ]; then
   # Default path with an existing install: probe PyPI and prompt before
   # upgrading, rather than silently pulling the latest version every run.
   # A pinned version or pre-release strategy (handled by the branches above and
@@ -609,8 +639,8 @@ fi
 #      instead of upgrading in place (e.g., Python interpreter mismatch, or
 #      editable↔regular install swap).
 #   2. Drop uv's per-step timing lines ("Resolved N packages in...", etc.)
-#      and the trailing "Installed N executables:" line — we already show
-#      a Verified line with the binary name and version.
+#      download/build progress, and the trailing "Installed N executables:" line
+#      — we already show a concise install/update summary.
 #   3. Reformat the `- pkg==X` / `+ pkg==Y` diff into an aligned
 #      "pkg  X → Y" table under a single header.
 #   4. Detect whether uv actually moved any packages (those same
@@ -652,7 +682,7 @@ if [ -n "$cache_root" ]; then
     fi
   fi
 fi
-if [[ -n "$PRERELEASE" ]]; then
+if [[ -z "$VERSION" ]]; then
   "$UV_BIN" tool install -U --python "$PYTHON_VERSION" \
     --prerelease "$PRERELEASE" "$PACKAGE" 2>"$uv_stderr" || uv_rc=$?
 else
@@ -665,12 +695,16 @@ if [ "$VERBOSE" != "1" ] && command -v awk >/dev/null 2>&1; then
       print "⚠ Existing environment uses a different Python — rebuilding from scratch (this is normal)."
       next
     }
-    /^Resolved [0-9]+ packages? in /    { next }
-    /^Prepared [0-9]+ packages? in /    { next }
-    /^Uninstalled [0-9]+ packages? in / { next }
-    /^Installed [0-9]+ packages? in /   { next }
-    /^Audited [0-9]+ packages? in /     { next }
-    /^Checked [0-9]+ packages? in /     { next }
+    /^Resolved( [0-9]+ packages?)? in /     { next }
+    /^Prepared [0-9]+ packages?( |$)/       { next }
+    /^Uninstalled [0-9]+ packages? in /     { next }
+    /^Installed [0-9]+ packages? in /       { next }
+    /^Audited( [0-9]+ packages?)? in /      { next }
+    /^Checked( [0-9]+ packages?)? in /      { next }
+    /^[[:space:]]*Downloading /         { next }
+    /^[[:space:]]*Downloaded /          { next }
+    /^[[:space:]]*Building /            { next }
+    /^[[:space:]]*Built /                { next }
     /^Installed [0-9]+ executables?:/   { next }
     /^ - / {
       s = $0; sub(/^ - /, "", s); n = index(s, "==")
@@ -968,7 +1002,7 @@ if [ "$SKIP_OPTIONAL" != "1" ]; then
     # PATH and honors DEEPAGENTS_CODE_OFFLINE and
     # DEEPAGENTS_CODE_RIPGREP_INSTALLER=system, reporting what it did.
     echo ""
-    log_info "Setting up ripgrep (managed; opt out with DEEPAGENTS_CODE_RIPGREP_INSTALLER=system)..."
+    log_info "Setting up ripgrep..."
     if "$DCODE_BIN" tools install; then
       fix_owner "${HOME}/.deepagents/bin"
     else

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/tests/unit_tests/test_app.py

@@ -33,7 +33,7 @@ from textual.screen import ModalScreen
 from textual.widget import Widget
 from textual.widgets import Checkbox, Input, Static
 
-from deepagents_code._version import CHANGELOG_URL
+from deepagents_code._version import CHANGELOG_URL, __version__
 from deepagents_code.app import (
     _DEEPAGENTS_IMPORT_LOCK,
     _TYPING_IDLE_THRESHOLD_SECONDS,
@@ -9161,8 +9161,9 @@ class TestDeferredActions:
             assert isinstance(widget, ErrorMessage)
             rendered = str(widget._content)
             assert (
-                "uv tool install --reinstall -U deepagents-code "
-                "--with langchain-custom_provider" in rendered
+                "uv tool install --reinstall -U "
+                f"deepagents-code=={__version__} "
+                "--with langchain-custom_provider --prerelease allow" in rendered
             )
             assert "/model custom_provider:<model>" in rendered
 

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/tests/unit_tests/test_config.py

@@ -12,6 +12,7 @@ import pytest
 
 from deepagents_code import _git as git_module, model_config
 from deepagents_code._env_vars import SERVER_ENV_PREFIX
+from deepagents_code._version import __version__
 from deepagents_code.config import (
     CLI_MAX_RETRIES_KEY,
     RECOMMENDED_SAFE_SHELL_COMMANDS,
@@ -3929,8 +3930,9 @@ class TestCreateModelViaInitImportError:
             pytest.raises(
                 ModelConfigError,
                 match=(
-                    "Install with: uv tool install --reinstall -U deepagents-code "
-                    "--with langchain-custom_provider"
+                    "Install with: uv tool install --reinstall -U "
+                    f"deepagents-code=={__version__} "
+                    "--with langchain-custom_provider --prerelease allow"
                 ),
             ),
         ):

{deepagents_code-0.1.25 → deepagents_code-0.1.26}/tests/unit_tests/test_install_script.py

@@ -292,13 +292,13 @@ def test_install_script_default_invocation_installs_plain_package(
     """A fresh machine installs the bare package with no prompt.
 
     Guards the most common `curl ... | bash` path against accidentally
-    appending a version pin, extras, or a `--prerelease` flag.
+    appending a version pin or extras, while allowing stable releases that pin
+    pre-release dependencies to resolve.
     """
     args = _run_install_script(tmp_path, {}, installed_version=None)
 
     assert args[:3] == ["tool", "install", "-U"]
-    assert args[-1] == "deepagents-code"
-    assert "--prerelease" not in args
+    assert args[-3:] == ["--prerelease", "allow", "deepagents-code"]
 
 
 def test_install_script_supports_exact_version_with_extras(tmp_path: Path) -> None:
@@ -583,7 +583,21 @@ _DEPENDENCY_UPDATE_DIFF = " - boto3==1.43.33\n + boto3==1.43.34"
 _DEPENDENCY_ADDITION_DIFF = " + brand-new-dep==1.0.0"
 
 # uv ran but moved nothing — only timing/summary noise, no `± pkg==ver` lines.
-_NO_PACKAGE_CHANGE_STDERR = "Resolved 5 packages in 12ms\nAudited 5 packages in 1ms"
+_NO_PACKAGE_CHANGE_STDERR = (
+    "Resolved 5 packages in 12ms\n"
+    "Resolved in 12ms\n"
+    "Prepared 1 package for build in 20ms\n"
+    "Checked in 1ms\n"
+    "Audited 5 packages in 1ms"
+)
+
+_UV_PROGRESS_STDERR = (
+    "Downloading uvloop (1.3MiB)\n"
+    " Downloading pygments (1.2MiB)\n"
+    "Downloaded uvloop\n"
+    "Building forbiddenfruit==0.1.4\n"
+    "Built forbiddenfruit==0.1.4"
+)
 
 
 def test_install_script_fresh_install_hides_packages(tmp_path: Path) -> None:
@@ -614,6 +628,41 @@ def test_install_script_verbose_lists_every_package(tmp_path: Path) -> None:
     assert "Installed 3 packages" not in proc.stderr
 
 
+def test_install_script_hides_uv_download_and_build_progress(tmp_path: Path) -> None:
+    """Non-verbose installs hide uv's download and build progress lines."""
+    proc, _ = _invoke(
+        tmp_path,
+        {"FAKE_UV_INSTALL_STDERR": _UV_PROGRESS_STDERR},
+        installed_version=None,
+    )
+
+    assert proc.returncode == 0
+    assert "Downloading uvloop" not in proc.stderr
+    assert "Downloaded uvloop" not in proc.stderr
+    assert "Building forbiddenfruit" not in proc.stderr
+    assert "Built forbiddenfruit" not in proc.stderr
+
+
+def test_install_script_verbose_shows_uv_download_and_build_progress(
+    tmp_path: Path,
+) -> None:
+    """Verbose installs preserve uv's raw download and build progress lines."""
+    proc, _ = _invoke(
+        tmp_path,
+        {
+            "FAKE_UV_INSTALL_STDERR": _UV_PROGRESS_STDERR,
+            "DEEPAGENTS_CODE_VERBOSE": "1",
+        },
+        installed_version=None,
+    )
+
+    assert proc.returncode == 0
+    assert "Downloading uvloop" in proc.stderr
+    assert "Downloaded uvloop" in proc.stderr
+    assert "Building forbiddenfruit" in proc.stderr
+    assert "Built forbiddenfruit" in proc.stderr
+
+
 def test_install_script_upgrade_still_shows_diff(tmp_path: Path) -> None:
     """An upgrade keeps its compact changed-package diff."""
     proc, _ = _invoke(
@@ -1182,6 +1231,92 @@ def test_install_script_linux_skips_clt_check(tmp_path: Path) -> None:
     assert uv_args.exists()
 
 
+def _invoke_with_local_uv_not_on_path(
+    tmp_path: Path, *, env_file_content: str | None = None
+) -> tuple[subprocess.CompletedProcess[str], Path]:
+    """Run with uv present only in ~/.local/bin, absent from PATH."""
+    bin_dir, home, uv = _write_fake_tools(
+        tmp_path, installed_version=None, latest_version="0.2.0"
+    )
+
+    local_bin = home / ".local" / "bin"
+    local_bin.mkdir(parents=True)
+    local_uv = local_bin / "uv"
+    local_uv.write_text(uv.read_text())
+    _make_executable(local_uv)
+    uv.unlink()
+    if env_file_content is not None:
+        (local_bin / "env").write_text(env_file_content)
+
+    path_without_uv = os.pathsep.join(
+        entry
+        for entry in _path_without_dcode().split(os.pathsep)
+        if entry and not (Path(entry) / "uv").exists()
+    )
+    env = {
+        **os.environ,
+        "HOME": str(home),
+        "XDG_CACHE_HOME": str(home / ".cache"),
+        "PATH": f"{bin_dir}{os.pathsep}{path_without_uv}",
+        "DEEPAGENTS_CODE_SKIP_OPTIONAL": "1",
+    }
+    proc = subprocess.run(
+        ["bash", str(SCRIPT)],
+        env=env,
+        check=False,
+        capture_output=True,
+        text=True,
+        stdin=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    return proc, tmp_path / "uv-args.txt"
+
+
+def test_install_script_uses_local_uv_when_not_on_path(tmp_path: Path) -> None:
+    """A minimal MDM PATH must not reinstall uv when ~/.local/bin/uv exists."""
+    proc, uv_args = _invoke_with_local_uv_not_on_path(tmp_path)
+
+    assert proc.returncode == 0
+    assert uv_args.exists()
+    assert "uv not found — installing" not in proc.stdout + proc.stderr
+    assert uv_args.read_text().splitlines()[:3] == ["tool", "install", "-U"]
+
+
+def test_install_script_sources_uv_env_file_defensively(tmp_path: Path) -> None:
+    """A non-zero command in uv's env file must not abort the installer."""
+    proc, uv_args = _invoke_with_local_uv_not_on_path(
+        tmp_path,
+        env_file_content='export PATH="$HOME/.local/bin:$PATH"\nfalse\n',
+    )
+
+    assert proc.returncode == 0
+    assert uv_args.exists()
+    assert "uv not found — installing" not in proc.stdout + proc.stderr
+    assert uv_args.read_text().splitlines()[:3] == ["tool", "install", "-U"]
+
+
+def test_install_script_rejects_invalid_uv_bin_without_installing(
+    tmp_path: Path,
+) -> None:
+    """A bad `UV_BIN` should fail clearly instead of reinstalling uv."""
+    cases = [
+        (tmp_path / "missing", tmp_path / "missing" / "uv"),
+        (tmp_path / "directory", tmp_path / "directory" / "uv"),
+    ]
+    cases[1][1].mkdir(parents=True)
+
+    for root, uv_bin in cases:
+        root.mkdir(exist_ok=True)
+        proc, uv_args = _invoke(root, {"UV_BIN": str(uv_bin)})
+
+        assert proc.returncode != 0
+        assert not uv_args.exists()
+        assert (
+            f"UV_BIN is set but does not point to an executable uv: {uv_bin}"
+            in proc.stderr
+        )
+
+
 def _invoke_with_local_dcode_not_on_path(
     tmp_path: Path, *, create_env_file: bool = False
 ) -> subprocess.CompletedProcess[str]:
@@ -1273,6 +1408,9 @@ def test_install_script_managed_ripgrep_calls_tools_install(tmp_path: Path) -> N
     tools_log = tmp_path / "dcode-tools.txt"
     assert tools_log.exists(), proc.stdout + proc.stderr
     assert "tools install" in tools_log.read_text()
+    combined = proc.stdout + proc.stderr
+    assert "Setting up ripgrep..." in combined
+    assert "opt out with DEEPAGENTS_CODE_RIPGREP_INSTALLER=system" not in combined
 
 
 def test_install_script_system_ripgrep_skips_tools_install(tmp_path: Path) -> None: