deepagents-code 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "981a87a"
+BUILD_COMMIT = "42e4f08"

deepagents_code/_checkpointer_adapter.py

@@ -0,0 +1,86 @@
+"""Forward delta-channel history reads through langgraph-api's saver adapter.
+
+The LangGraph dev server wraps a custom checkpointer in
+`langgraph_api._checkpointer._adapter._CustomCheckpointerAdapter`. The adapter
+forwards unknown attributes to the inner saver through `__getattr__`, but
+`BaseCheckpointSaver` already defines `aget_delta_channel_history`, so the
+forwarding never fires. The adapter then runs the base ancestor walk: one
+`aget_tuple` and one full checkpoint decode per ancestor. The SQLite saver
+overrides the method with two indexed queries, and long threads pay the
+difference on every state read and every run start.
+
+This module is a best-effort patch over a private langgraph-api class. It only
+patches when the adapter still inherits the base method, and it falls back to
+the base walk when the inner saver has no override of its own. Remove it when
+the adapter forwards these methods itself.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from langchain_core.runnables import RunnableConfig
+    from langgraph.checkpoint.base import DeltaChannelHistory
+
+logger = logging.getLogger(__name__)
+
+_BASE_ASYNC = BaseCheckpointSaver.aget_delta_channel_history
+_BASE_SYNC = BaseCheckpointSaver.get_delta_channel_history
+
+
+def _overriding_inner(
+    adapter: BaseCheckpointSaver, name: str
+) -> BaseCheckpointSaver | None:
+    """Return the adapter's inner saver if it overrides the base method `name`."""
+    inner = adapter.__dict__.get("_inner")
+    if not isinstance(inner, BaseCheckpointSaver):
+        return None
+    if getattr(type(inner), name) is getattr(BaseCheckpointSaver, name):
+        return None
+    return inner
+
+
+async def _aget_delta_channel_history(
+    self: BaseCheckpointSaver, *, config: RunnableConfig, channels: Sequence[str]
+) -> Mapping[str, DeltaChannelHistory]:
+    inner = _overriding_inner(self, "aget_delta_channel_history")
+    if inner is None:
+        return await _BASE_ASYNC(self, config=config, channels=channels)
+    return await inner.aget_delta_channel_history(config=config, channels=channels)
+
+
+def _get_delta_channel_history(
+    self: BaseCheckpointSaver, *, config: RunnableConfig, channels: Sequence[str]
+) -> Mapping[str, DeltaChannelHistory]:
+    inner = _overriding_inner(self, "get_delta_channel_history")
+    if inner is None:
+        return _BASE_SYNC(self, config=config, channels=channels)
+    return inner.get_delta_channel_history(config=config, channels=channels)
+
+
+def install_delta_history_forwarding() -> None:
+    """Make langgraph-api's checkpointer adapter use the inner saver's fast path.
+
+    Call this in the server process before the adapter serves requests. It is
+    idempotent and a no-op when the adapter is missing or already overrides
+    the methods.
+    """
+    try:
+        # The adapter has no public seam; this patch exists to reach it.
+        from langgraph_api._checkpointer._adapter import (  # noqa: PLC2701
+            _CustomCheckpointerAdapter,
+        )
+    except ImportError:
+        logger.warning("langgraph-api checkpointer adapter not found; skipping patch")
+        return
+    adapter = _CustomCheckpointerAdapter
+    if adapter.aget_delta_channel_history is _BASE_ASYNC:
+        adapter.aget_delta_channel_history = _aget_delta_channel_history
+    if adapter.get_delta_channel_history is _BASE_SYNC:
+        adapter.get_delta_channel_history = _get_delta_channel_history

deepagents_code/_env_vars.py

@@ -77,6 +77,15 @@ Values outside 1-900 seconds are ignored in favor of the next config source.
 Also settable via `[mcp].tool_timeout` in config.toml.
 """
 
+ASK_ABOUT_SELECTION = "DEEPAGENTS_CODE_ASK_ABOUT_SELECTION"
+"""Show "Ask about this" when conversation text is selected.
+
+Enabled by default; set to a falsy value (`0`, `false`, `no`, `off`) to hide
+it. Parsed by `classify_env_bool` (an unrecognized or empty value falls through
+to the config value rather than forcing the default). Also settable via
+`[ui].ask_about_selection` in config.toml. `/reload` applies a change.
+"""
+
 AUTO_UPDATE = "DEEPAGENTS_CODE_AUTO_UPDATE"
 """Toggle automatic app updates. Enabled by default; set to a falsy value
 ('0', 'false', 'no', 'off', or empty) to opt out."""
@@ -277,13 +286,20 @@ EXPERIMENTAL = "DEEPAGENTS_CODE_EXPERIMENTAL"
 Off by default; parsed by `is_env_truthy` (see there for the accepted truthy
 values). Marks experimental runs in UI/trace metadata. Behavior behind this
 flag may change or be removed without notice.
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
 """
 
 EXTENSIONS = "DEEPAGENTS_CODE_EXTENSIONS"
 """Enable loading installed-plugin and trusted-project Python extensions."""
 
 EXTENSIONS_TRUST = "DEEPAGENTS_CODE_EXTENSIONS_TRUST"
-"""Default project extension trust policy: `ask`, `always`, or `never`."""
+"""Default project extension trust policy: `ask`, `always`, or `never`.
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
+"""
 
 EXTERNAL_EVENT_SOCKET = "DEEPAGENTS_CODE_EXTERNAL_EVENT_SOCKET"
 """Enable the local Unix-socket external event listener.
@@ -296,7 +312,11 @@ EXTERNAL_EVENT_SOCKET_PATH = "DEEPAGENTS_CODE_EXTERNAL_EVENT_SOCKET_PATH"
 """Override the default Unix-socket path for the external event listener."""
 
 EXTRA_SKILLS_DIRS = "DEEPAGENTS_CODE_EXTRA_SKILLS_DIRS"
-"""Paths added to the skill containment allowlist, split with `os.pathsep`."""
+"""Paths added to the skill containment allowlist, split with `os.pathsep`.
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
+"""
 
 GOAL_AUTO_ACCEPT_CRITERIA = "DEEPAGENTS_CODE_GOAL_AUTO_ACCEPT_CRITERIA"
 """Apply generated goal criteria automatically in Auto mode.
@@ -485,6 +505,8 @@ PLUGIN_CACHE_DIR = "DEEPAGENTS_CODE_PLUGIN_CACHE_DIR"
 """Override the plugin install/marketplace cache root.
 
 When unset, plugins are stored under `DEFAULT_CONFIG_DIR / "plugins"`.
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
 """
 
 PRICES_AUTO_UPDATE = "DEEPAGENTS_CODE_PRICES_AUTO_UPDATE"
@@ -564,7 +586,11 @@ SERVER_ENV_PREFIX = "DEEPAGENTS_CODE_SERVER_"
 """Environment variable prefix used to pass CLI config to the server subprocess."""
 
 SHELL_ALLOW_LIST = "DEEPAGENTS_CODE_SHELL_ALLOW_LIST"
-"""Comma-separated shell commands to allow (or 'recommended'/'all')."""
+"""Comma-separated shell commands to allow (or 'recommended'/'all').
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
+"""
 
 SHOW_HEADER = "DEEPAGENTS_CODE_SHOW_HEADER"
 """Show Textual's native header bar at the top of the TUI when enabled."""

deepagents_code/_git.py

@@ -17,6 +17,9 @@ _GIT_DIR_POINTER_PREFIX = "gitdir: "
 _GIT_HEAD_REF_PREFIX = "ref: "
 """Prefix used by `HEAD` when it points at a named ref instead of a commit."""
 
+_REFTABLE_HEAD_PLACEHOLDER = "refs/heads/.invalid"
+"""Ref a reftable repository writes to `HEAD`; the real refs live in `reftable/`."""
+
 _GIT_REF_PREFIXES = ("refs/heads/", "refs/remotes/", "refs/tags/", "refs/")
 """Known git ref prefixes stripped when formatting a branch-like display name."""
 
@@ -411,7 +414,8 @@ def read_git_branch_from_filesystem(path: str | Path) -> str | None:
     Returns:
         The abbreviated branch name, `HEAD` for detached HEAD, an empty string
         when `path` is not inside a git repository, or `None` when metadata
-        exists but cannot be parsed confidently.
+        exists but cannot be parsed confidently (including reftable
+        repositories, whose `HEAD` file only holds a placeholder).
     """
     git_dir = find_git_dir(path)
     if git_dir is None:
@@ -431,7 +435,9 @@ def read_git_branch_from_filesystem(path: str | Path) -> str | None:
         return ""
     if head.startswith(_GIT_HEAD_REF_PREFIX):
         ref = head.removeprefix(_GIT_HEAD_REF_PREFIX).strip()
-        return _abbreviate_git_ref(ref) if ref else None
+        if not ref or ref == _REFTABLE_HEAD_PLACEHOLDER:
+            return None
+        return _abbreviate_git_ref(ref)
     return "HEAD"
 
 

deepagents_code/_js_cost.py

@@ -7,6 +7,7 @@ import dataclasses
 import hashlib
 import itertools
 import json
+import logging
 import math
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, override
@@ -19,6 +20,7 @@ from langgraph.checkpoint.base import (
     empty_checkpoint,
 )
 from langgraph.config import get_config
+from langgraph.errors import GraphBubbleUp, NodeCancelledError
 from langgraph.types import Command
 
 from deepagents_code.cost_tracking import (
@@ -37,6 +39,8 @@ if TYPE_CHECKING:
 
     from deepagents_code.cost_tracking import CostBreakdown
 
+logger = logging.getLogger(__name__)
+
 _ACCOUNTING_KEY = "__deepagents_js_cost_owner"
 _RESPONSE_FORMAT_KEY = "__deepagents_subagent_response_format"
 
@@ -172,6 +176,17 @@ def _cost_task(
                 config=config,
                 tool_call_id=runtime.tool_call_id,
             )
+        except asyncio.CancelledError, GraphBubbleUp, NodeCancelledError:
+            raise
+        except Exception as exc:
+            logger.debug("Subagent %r failed", subagent_type, exc_info=exc)
+            return {
+                "error": (
+                    f"Subagent {subagent_type!r} failed: "
+                    f"{type(exc).__name__}: {str(exc)[:300]}. You may retry this task."
+                ),
+                "failed": True,
+            }
         finally:
             if invocation is not None:
                 active.discard(invocation)

deepagents_code/_langsmith_runtime.py

@@ -0,0 +1,91 @@
+"""Run untraced `@traceable` bookkeeping inline on the server loop.
+
+LangChain wraps every middleware `awrap_tool_call` and `awrap_model_call` hook
+in `langsmith.traceable`. Its async wrapper sends two calls to a worker thread
+per hook: one to set up the run and one to end it. It does this even when
+tracing is off and both calls only build an empty container. About 20 traced
+hooks run per tool round trip, so each round trip pays for about 40 thread
+hops that do no work.
+
+`install_untraced_inline_override` installs a LangSmith runtime override. The
+override runs those two calls inline when they cannot trace, and gives every
+other call to LangSmith's default thread hop.
+"""
+
+from __future__ import annotations
+
+import functools
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import contextvars
+    from collections.abc import Awaitable, Callable
+
+    DefaultAioToThread = Callable[..., Awaitable[Any]]
+
+logger = logging.getLogger(__name__)
+
+
+def _target(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Return the function a `functools.partial` wraps, else `func` itself.
+
+    Returns:
+        The underlying callable.
+    """
+    return func.func if isinstance(func, functools.partial) else func
+
+
+def _runs_inline(
+    ctx: contextvars.Context,
+    func: Callable[..., Any],
+    args: tuple[Any, ...],
+) -> bool:
+    """Whether a `traceable` bookkeeping call cannot trace, so it is cheap.
+
+    Only run setup and run end qualify. Any other call (for example an async
+    `Client` API method) can do network I/O, so it keeps the thread hop.
+
+    Returns:
+        `True` when the call is safe to run on the event loop.
+    """
+    from langsmith import run_helpers
+    from langsmith.utils import tracing_is_enabled
+
+    target = _target(func)
+    if target is getattr(run_helpers, "_setup_run", None):
+        return not ctx.run(tracing_is_enabled)
+    if target is getattr(run_helpers, "_handle_container_end", None):
+        container = args[0] if args else None
+        return isinstance(container, dict) and container.get("new_run") is None
+    return False
+
+
+async def _untraced_inline_aio_to_thread(
+    default: DefaultAioToThread,
+    ctx: contextvars.Context,
+    func: Callable[..., Any],
+    /,
+    *args: Any,  # forwards arbitrary LangSmith call arguments
+    **kwargs: Any,  # forwards arbitrary LangSmith call arguments
+) -> Any:  # noqa: ANN401  # returns whatever `func` returns
+    """Run untraced bookkeeping inline; hop to a thread for everything else.
+
+    Returns:
+        The result of `func`.
+    """
+    if _runs_inline(ctx, func, args):
+        return ctx.run(func, *args, **kwargs)
+    return await default(ctx, func, *args, **kwargs)
+
+
+def install_untraced_inline_override() -> None:
+    """Install the override for this process.
+
+    The override is process-global. Call it only in the server process, which
+    owns its event loop and pins one tracing configuration for its lifetime.
+    """
+    import langsmith
+
+    langsmith.set_runtime_overrides(aio_to_thread=_untraced_inline_aio_to_thread)
+    logger.debug("Installed inline LangSmith runtime override for untraced runs")

deepagents_code/_run_queue_wakeup.py

@@ -0,0 +1,156 @@
+"""Wake the in-memory run queue when a run is created.
+
+The server runs on `langgraph_runtime_inmem`. Its background scheduler polls
+for pending runs: `Runs.next(wait=True)` sleeps 0.5 s, then claims only runs
+created before that sleep began. Every user turn and every interrupt resume is
+a new run, so each one waits 0.5-1.0 s before a worker starts it.
+
+This patch makes `Runs.put` set an event and makes a waiting `Runs.next` wait
+on that event instead of the fixed sleep. The stock `Runs.next` still claims
+the runs, so queue order and per-thread locking do not change. The 0.5 s
+timeout stays as a fallback, so a missed wakeup costs at most the stock delay.
+
+`Runs.next` and `Runs.put` are private APIs. If their shape is not what this
+module expects, the patch logs at debug level and does nothing. Remove this
+module when `langgraph_runtime_inmem` wakes the scheduler on put.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import functools
+import inspect
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable
+
+logger = logging.getLogger(__name__)
+
+_POLL_INTERVAL = 0.5
+"""Fallback wait in seconds; matches the stock `Runs.next` sleep."""
+
+_PATCHED_MARKER = "_dcode_run_queue_wakeup"
+"""Attribute set on each wrapper so a second install is a no-op."""
+
+
+class _Wakeup:
+    """Edge-triggered signal from `Runs.put` to a waiting `Runs.next`.
+
+    The event binds to the scheduler loop on the first wait. A put before
+    that first wait is not lost: the scheduler then waits the fallback
+    interval, as stock does.
+    """
+
+    def __init__(self) -> None:
+        self._event: asyncio.Event | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    async def wait(self) -> None:
+        """Wait until a run is put, or until the fallback interval passes."""
+        if self._event is None:
+            self._event = asyncio.Event()
+            self._loop = asyncio.get_running_loop()
+        with contextlib.suppress(TimeoutError):
+            async with asyncio.timeout(_POLL_INTERVAL):
+                await self._event.wait()
+        self._event.clear()
+
+    def notify(self) -> None:
+        """Wake the scheduler; safe from any thread and after loop close."""
+        event, loop = self._event, self._loop
+        if event is None or loop is None:
+            return
+        # The loop can close during shutdown; the wakeup is then moot.
+        with contextlib.suppress(RuntimeError):
+            loop.call_soon_threadsafe(event.set)
+
+
+_WAKEUP = _Wakeup()
+
+
+def _wrap_next(
+    original: Callable[[bool, int], AsyncIterator[object]],
+) -> Callable[[bool, int], AsyncIterator[object]]:
+    """Replace the fixed poll sleep with a wait on `_WAKEUP`.
+
+    Returns:
+        A drop-in replacement for the upstream `Runs.next`.
+    """
+
+    @functools.wraps(original)
+    async def next_runs(wait: bool, limit: int = 1) -> AsyncIterator[object]:
+        if wait:
+            await _WAKEUP.wait()
+        # `wait=False` skips the sleep and claims runs created before now,
+        # which includes the run that woke us.
+        async for item in original(False, limit):
+            yield item
+
+    setattr(next_runs, _PATCHED_MARKER, True)
+    return next_runs
+
+
+def _wrap_put(
+    original: Callable[..., Awaitable[object]],
+) -> Callable[..., Awaitable[object]]:
+    """Notify `_WAKEUP` after each run insert.
+
+    Returns:
+        A drop-in replacement for the upstream `Runs.put`.
+    """
+
+    @functools.wraps(original)
+    async def put(*args: object, **kwargs: object) -> object:
+        result = await original(*args, **kwargs)
+        _WAKEUP.notify()
+        return result
+
+    setattr(put, _PATCHED_MARKER, True)
+    return put
+
+
+def _has_expected_shape(runs: type) -> bool:
+    """Check that `Runs.next` and `Runs.put` look like the pinned version.
+
+    Returns:
+        `True` when both are static methods with the expected signatures.
+    """
+    next_attr = runs.__dict__.get("next")
+    put_attr = runs.__dict__.get("put")
+    if not isinstance(next_attr, staticmethod) or not isinstance(
+        put_attr, staticmethod
+    ):
+        return False
+    next_fn, put_fn = next_attr.__func__, put_attr.__func__
+    params = list(inspect.signature(next_fn).parameters)
+    return (
+        inspect.isasyncgenfunction(next_fn)
+        and params[:2] == ["wait", "limit"]
+        and inspect.iscoroutinefunction(put_fn)
+    )
+
+
+def install_run_queue_wakeup() -> bool:
+    """Patch the in-memory run queue to start new runs without the poll delay.
+
+    Returns:
+        `True` when the patch is active after the call, else `False`.
+    """
+    try:
+        from langgraph_runtime_inmem.ops import Runs
+    except ImportError:
+        logger.debug("Run queue wakeup skipped: in-memory runtime not installed")
+        return False
+    if getattr(Runs.next, _PATCHED_MARKER, False):
+        return True
+    if not _has_expected_shape(Runs):
+        logger.debug("Run queue wakeup skipped: Runs.next/put changed upstream")
+        return False
+    wrappers = {"next": _wrap_next, "put": _wrap_put}
+    for name, wrap in wrappers.items():
+        setattr(Runs, name, staticmethod(wrap(getattr(Runs, name))))
+    logger.debug("Run queue wakeup installed")
+    return True

deepagents_code/_session_lock.py

@@ -0,0 +1,184 @@
+"""Presence lock telling a launch whether other dcode sessions share its install.
+
+A Python migration rebuilds the uv tool environment, which breaks every dcode
+process — and every server it spawned — still running from the old one. Startup
+auto-update may only migrate when no other session uses the installation, and
+it cannot tell that from a process listing: shims, renamed symlinks, and the
+server bootstrap all run under different names.
+
+Instead, each dcode process of a non-editable install (editable installs never
+auto-update) holds a shared `flock` on `SESSION_LOCK_FILE` for its lifetime,
+and hands the descriptor to the servers it spawns so they hold
+the same lock. A process asking "am I alone?" tries to take the lock
+exclusively; that succeeds only when no other session's open file holds it.
+The kernel drops a lock when its last descriptor closes, so a crashed session
+can never leave a stale claim behind.
+
+The answer is a snapshot. It cannot see sessions of versions from before this
+lock existed, and nothing stops a session that launches while the migration
+runs; both are accepted as rare and recoverable by a relaunch.
+
+POSIX only. On Windows, or whenever the lock cannot be taken, a process is
+never reported as alone, so the migration stays deferred to `dcode update`.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from typing import TYPE_CHECKING
+
+from deepagents_code._paths import PATHS
+
+if sys.platform != "win32":
+    import fcntl
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+SESSION_LOCK_FILE: Path = PATHS.installation.locks_dir / "sessions.lock"
+"""Advisory lock held shared by every registered dcode process of one installation.
+
+Lives beside `update.lock`, outside the tool environment, so a migration that
+rebuilds the environment keeps the same file. Carries no data.
+
+Installation-scoped only, with no per-profile fallback: a profile-scoped lock
+would hide sessions of other profiles, and over-reporting "alone" is the one
+failure this lock must not have.
+"""
+
+_held_fd: int | None = None
+"""Descriptor holding this process's shared lock, or `None` when not held."""
+
+
+def hold_session_lock() -> None:
+    """Register this process as a running session for its lifetime.
+
+    Idempotent and fail-soft: when the lock cannot be taken, the process runs
+    unregistered and `is_sole_session` reports `False`. The descriptor is
+    non-inheritable, so the re-exec after an update drops it and the new
+    process registers itself again.
+    """
+    global _held_fd  # noqa: PLW0603  # one registration per process
+    if _held_fd is not None or sys.platform == "win32":
+        return
+    try:
+        SESSION_LOCK_FILE.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        fd = os.open(SESSION_LOCK_FILE, os.O_RDWR | os.O_CREAT, 0o600)
+    except OSError:
+        logger.warning(
+            "Could not open session lock %s", SESSION_LOCK_FILE, exc_info=True
+        )
+        return
+    try:
+        # Blocks only while another process is inside `is_sole_session`, the
+        # one place the lock is ever held exclusively, and only for an instant.
+        # Failing fast instead would leave this session invisible to that check.
+        fcntl.flock(fd, fcntl.LOCK_SH)
+    except OSError:
+        logger.warning(
+            "Could not take session lock %s", SESSION_LOCK_FILE, exc_info=True
+        )
+        os.close(fd)
+        return
+    _held_fd = fd
+
+
+def session_lock_fds() -> tuple[int, ...]:
+    """Return descriptors a spawned server must inherit to count as this session.
+
+    `flock` locks belong to the open file description, so a child given the
+    descriptor holds the same lock: the server keeps the install marked in use
+    if it outlives its client, and does not count as a second session.
+    """
+    return () if _held_fd is None else (_held_fd,)
+
+
+def session_lock_unavailable() -> bool:
+    """Return whether this POSIX process failed to register as a session.
+
+    Lets callers tell "other sessions are running" apart from "presence cannot
+    be known", which quitting other sessions would never fix.
+    """
+    return sys.platform != "win32" and _held_fd is None
+
+
+def is_sole_session() -> bool:
+    """Return whether no other dcode session holds this installation.
+
+    Converting a `flock` is not atomic: the shared lock is released before the
+    exclusive one is tried, so two processes checking at once could each see
+    the other as absent. An exclusive lock on `sessions.check.lock` beside
+    `SESSION_LOCK_FILE` admits one checker at a time; a process that finds it
+    taken is not alone.
+
+    Returns:
+        `True` only when this process holds the session lock and could take
+            it exclusively. `False` when another session holds it, or when the
+            lock is unavailable and presence cannot be known.
+    """
+    if _held_fd is None:
+        return False
+    check_file = SESSION_LOCK_FILE.with_name("sessions.check.lock")
+    try:
+        guard = os.open(check_file, os.O_RDWR | os.O_CREAT, 0o600)
+    except OSError:
+        logger.warning("Could not open %s", check_file, exc_info=True)
+        return False
+    try:
+        fcntl.flock(guard, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        return False
+    else:
+        return _probe_exclusive(_held_fd)
+    finally:
+        os.close(guard)
+
+
+def _probe_exclusive(fd: int) -> bool:
+    """Try to take the session lock exclusively, then hold it shared again.
+
+    Returns:
+        Whether the exclusive attempt succeeded and the shared lock is back.
+    """
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        sole = False
+    except OSError:
+        logger.warning(
+            "Could not check session lock %s", SESSION_LOCK_FILE, exc_info=True
+        )
+        sole = False
+    else:
+        sole = True
+    # Re-take it on both branches: on Linux a failed upgrade attempt has already
+    # released the shared lock.
+    return _restore_shared(fd) and sole
+
+
+def _restore_shared(fd: int) -> bool:
+    """Hold the session lock shared again, or unregister on failure.
+
+    Returns:
+        Whether this process is still registered.
+    """
+    global _held_fd  # noqa: PLW0603  # unregister a lock this process lost
+    try:
+        # Blocking is safe: the check lock is held, so no other process holds
+        # this lock exclusively.
+        fcntl.flock(fd, fcntl.LOCK_SH)
+    except OSError:
+        logger.warning(
+            "Could not restore the shared session lock %s; other dcode sessions "
+            "will not see this one",
+            SESSION_LOCK_FILE,
+            exc_info=True,
+        )
+        _held_fd = None
+        os.close(fd)
+        return False
+    return True

deepagents_code/_textual_patches.py

@@ -293,6 +293,11 @@ else:
 
 
 def _rendered_text(widget: Widget) -> str | None:
+    # A widget that renders a custom visual (such as `FinalMarkdown`) can
+    # publish the text its selection offsets index into.
+    selectable = getattr(widget, "selectable_text", None)
+    if isinstance(selectable, str):
+        return selectable
     visual = widget._render()  # match Textual's get_selection path
     if isinstance(visual, (Content, Text)):
         return str(visual)