ipinb 0.2.0__tar.gz → 0.3.0__tar.gz

{ipinb-0.2.0 → ipinb-0.3.0}/BREAKING_CHANGES.md

@@ -1,5 +1,13 @@
 # Breaking Changes
 
+## 2026-10-27: Private uv kernel environments (0.3.0)
+
+Every local and SSH kernel uses an isolated uv environment. Runtime and additional dependencies may override project pins inside that environment. IPi no longer turns every installed project version into a constraint. Project `.venv` and `uv.lock` stay unchanged. Live `%pip` changes remain private to the kernel. Strict `kernel.locked` checks the base project's lock; overlay versions may still differ.
+
+The `venv` argument is removed from `create_kernel`, `Kernel.launch`, and transport launch requests, and from returned kernel records. IPi requires uv 0.12.3 or later on the execution host. Existing running servers and kernels retain their old behavior until restarted.
+
+**Migration:** Upgrade uv, remove `venv` arguments, and set `cwd` to the intended uv project or scratch directory. Put project requirements in its `pyproject.toml`, and pass kernel-only requirements through `additional_dependencies`. Use project Python selection such as `.python-version`; do not build a separate venv for IPi. Review workflows that assumed kernel imports must use exactly the project's locked versions. New calls to a failed kernel now report `kernel_setup_failed` with the stored cause instead of `kernel_closed`; explicitly closed kernels keep the closed response.
+
 ## 2026-10-24: No host hook support (0.2.0)
 
 IPi 0.2.0 is a plain MCP notebook server. It installs no hooks and receives no host events.

{ipinb-0.2.0 → ipinb-0.3.0}/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable user-facing changes are recorded here. Detailed API removals and
 migration steps are maintained in [BREAKING_CHANGES.md](BREAKING_CHANGES.md).
 
+## 0.3.0
+
+- Restore native uv dependency overrides in private per-kernel environments. Runtime dependencies can override project pins without changing project environments or lockfiles; live installs stay private to each kernel.
+- Remove explicit `venv` attachment from kernel APIs and records. Select the project through `cwd` and request extra packages through `additional_dependencies`.
+- Require uv 0.12.3 or later for local and SSH kernels. Keep temporary lock resolution by default and optional strict base-lock validation.
+- Return the original redacted kernel setup error when Python is submitted after startup failed, rather than the generic `kernel_closed` error.
+
 ## 0.2.0
 
 - Breaking: IPi has no host hook support. Start context, the session trace, harness Bash commands as notebook cells, `bash[...]` shell history, the inline-Python nudge, and Claude session identity in kernels are gone (Codex kernels keep `CODEX_THREAD_ID`); the `install`, `install-hooks` and `doctor-narration` commands, the plugin hook API, `ipi.import_path` (use `toolfuncs.load`), the `ipi` command alias and the empty `mcp` extra are removed; IPi requires `toolfuncs>=3,<4`. See [BREAKING_CHANGES.md](BREAKING_CHANGES.md).

{ipinb-0.2.0 → ipinb-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipinb
-Version: 0.2.0
+Version: 0.3.0
 Summary: Persistent IPython notebooks for MCP agents
 Author-email: Nima Shoghi <nimashoghi@gmail.com>
 License-Expression: MIT
@@ -244,7 +244,7 @@ SSH URI:
 ```python
 create_kernel(cwd="/Users/me/local-project")
 create_kernel(cwd="ssh://gpu-box/opt/projects/model")
-create_kernel(cwd="ssh://alice@gpu-box:2222/opt/projects/model", venv=".venv")
+create_kernel(cwd="ssh://alice@gpu-box:2222/opt/projects/model")
 ```
 
 The URI path is the absolute working directory on the target. Host aliases,
@@ -333,9 +333,9 @@ Fresh kernels make a small general-purpose module set available: `typing_extensi
 
 Use `publication.shared_dependencies` for packages that must be installed in both the kernel and the lazily created Notebook 7 environment, such as packages that ship a JupyterLab frontend extension. Shared entries are automatically included in every kernel, so do not duplicate them under `kernel.additional_dependencies`. The publisher uses the exact package versions and sources selected by its kernel. Ordinary kernel-only packages remain in `kernel.additional_dependencies`; installing one live with `%pip` requires no publication change. Put personal scientific and widget defaults in `kernel.scratch_dependencies` and `publication.scratch_shared_dependencies` to keep them out of project kernels.
 
-Local and SSH kernels use ephemeral `uv run --isolated` environments. uv selects the project, workspace membership, Python interpreter, sources, and normal default groups. IPi does not enable all extras or groups. Missing or stale locks are resolved temporarily without writing `uv.lock`, and IPi does not create or synchronize `.venv`. Set `kernel.locked = true` to require an existing current lock. An explicit `venv` remains supported and is reused without synchronization; it cannot be combined with locked project preparation.
+Local and SSH kernels use ephemeral `uv run --isolated` environments. uv selects the project, workspace membership, Python interpreter, sources, and normal default groups. IPi does not enable all extras or groups. Missing or stale locks are resolved temporarily without writing `uv.lock`, and IPi does not create or synchronize `.venv`. Set `kernel.locked = true` to require an existing current lock. Strict-lock mode checks the base project lock; kernel overrides can still select different package versions.
 
-IPi captures the base environment selected by uv and constrains added kernel packages to that selection. Incompatible additions fail instead of shadowing project packages. Approved direnv settings apply to preparation and launch; IPi does not approve an `.envrc`.
+IPi requires uv 0.12.3 or later. Its runtime and additional dependencies use native uv overlays and may override project package pins. Each kernel has a private writable environment: live `%pip` changes affect only that kernel. Select the project with `cwd` and request extra packages with `additional_dependencies`; explicit venv attachment is not supported. Approved direnv settings apply to preparation and launch; IPi does not approve an `.envrc`.
 
 When `tools.view_image` is omitted, the public tool is disabled on stdio and
 enabled on HTTP, SSE, and streamable HTTP. Set it explicitly to `true` or

{ipinb-0.2.0 → ipinb-0.3.0}/README.md

@@ -201,7 +201,7 @@ SSH URI:
 ```python
 create_kernel(cwd="/Users/me/local-project")
 create_kernel(cwd="ssh://gpu-box/opt/projects/model")
-create_kernel(cwd="ssh://alice@gpu-box:2222/opt/projects/model", venv=".venv")
+create_kernel(cwd="ssh://alice@gpu-box:2222/opt/projects/model")
 ```
 
 The URI path is the absolute working directory on the target. Host aliases,
@@ -290,9 +290,9 @@ Fresh kernels make a small general-purpose module set available: `typing_extensi
 
 Use `publication.shared_dependencies` for packages that must be installed in both the kernel and the lazily created Notebook 7 environment, such as packages that ship a JupyterLab frontend extension. Shared entries are automatically included in every kernel, so do not duplicate them under `kernel.additional_dependencies`. The publisher uses the exact package versions and sources selected by its kernel. Ordinary kernel-only packages remain in `kernel.additional_dependencies`; installing one live with `%pip` requires no publication change. Put personal scientific and widget defaults in `kernel.scratch_dependencies` and `publication.scratch_shared_dependencies` to keep them out of project kernels.
 
-Local and SSH kernels use ephemeral `uv run --isolated` environments. uv selects the project, workspace membership, Python interpreter, sources, and normal default groups. IPi does not enable all extras or groups. Missing or stale locks are resolved temporarily without writing `uv.lock`, and IPi does not create or synchronize `.venv`. Set `kernel.locked = true` to require an existing current lock. An explicit `venv` remains supported and is reused without synchronization; it cannot be combined with locked project preparation.
+Local and SSH kernels use ephemeral `uv run --isolated` environments. uv selects the project, workspace membership, Python interpreter, sources, and normal default groups. IPi does not enable all extras or groups. Missing or stale locks are resolved temporarily without writing `uv.lock`, and IPi does not create or synchronize `.venv`. Set `kernel.locked = true` to require an existing current lock. Strict-lock mode checks the base project lock; kernel overrides can still select different package versions.
 
-IPi captures the base environment selected by uv and constrains added kernel packages to that selection. Incompatible additions fail instead of shadowing project packages. Approved direnv settings apply to preparation and launch; IPi does not approve an `.envrc`.
+IPi requires uv 0.12.3 or later. Its runtime and additional dependencies use native uv overlays and may override project package pins. Each kernel has a private writable environment: live `%pip` changes affect only that kernel. Select the project with `cwd` and request extra packages with `additional_dependencies`; explicit venv attachment is not supported. Approved direnv settings apply to preparation and launch; IPi does not approve an `.envrc`.
 
 When `tools.view_image` is omitted, the public tool is disabled on stdio and
 enabled on HTTP, SSE, and streamable HTTP. Set it explicitly to `true` or

{ipinb-0.2.0 → ipinb-0.3.0}/docs/architecture.md

@@ -2,6 +2,12 @@
 
 IPi is a notebook runtime exposed through MCP. Codex or Claude Code owns the agent loop; IPi owns persistent IPython kernels, execution records, notebooks, and artifacts. IPi installs and receives no host hooks.
 
+## Kernel environment ownership
+
+Local and SSH kernels require uv 0.12.3 or later and use one `uv run --isolated` path. uv discovers the project/workspace, Python, local sources, and default groups. Runtime and task requirements use native overlays that can override project pins. IPi does not freeze the base package inventory, attach existing venvs, synchronize `.venv`, or write `uv.lock`. Missing or stale locks resolve temporarily unless `kernel.locked` requires a current base lock. Each launch has a private writable environment, including when uv can skip an already-satisfied overlay. Live package changes belong to that kernel.
+
+Kernel setup remains asynchronous. Work accepted during setup receives its retained setup failure if provisioning fails. New Python submissions after failure return the same redacted cause, with the kernel ID. Replaying an accepted request ID still recovers the original cell.
+
 ## Distribution Boundary
 
 Installed archive plugins accept content hashes from PEP 610 `archive_info` or the URL hash fragment retained by uv for local wheels. Both forms produce the same source identity. Conflicting hashes, malformed fragments, and archives with no content hash remain errors.

{ipinb-0.2.0/ipi/skills/notebook/references → ipinb-0.3.0/docs}/kernel-environments.md

@@ -10,11 +10,11 @@ Reuse a suitable kernel ID already provided in context. When creating a kernel,
 create_kernel(cwd="/absolute/project", additional_dependencies=["numpy", "pandas"], request_id="analysis-kernel")
 ```
 
-The result may report `starting`. Python submitted with its returned `kernel_id` waits for setup. Inspect failed setup through the kernel record rather than assuming an accepted creation is ready. Configuration and plugins resolve for that kernel's cwd; a kernel created for another project can have a different environment.
+The result may report `starting`. Python submitted with its returned `kernel_id` waits for setup. Submit work with the returned ID and observe its cell; setup failures are returned directly even if setup failed before submission. Configuration and plugins resolve for that kernel's cwd; a kernel created for another project can have a different environment.
 
 IPi uses ephemeral `uv run --isolated` environments. uv selects the project or workspace member for `cwd`, its Python version, sources, and normal default dependency groups. IPi does not create or synchronize `.venv`. It resolves missing or stale locks temporarily without writing `uv.lock`; set `kernel.locked = true` in IPi configuration when a current lock is required. Approved direnv settings apply before resolution. IPi does not approve an `.envrc`.
 
-Added kernel dependencies must remain compatible with every package selected by the project. Conflicts fail without replacing those packages. Prefer `additional_dependencies` at creation for task requirements. Personal defaults in `kernel.scratch_dependencies` and `publication.scratch_shared_dependencies` apply only outside a uv project. An explicit `venv` selects an existing base without synchronizing it; it cannot be combined with locked project preparation. Live `%pip` changes are disposable. The environment hint describes available modules and distribution/import aliases. Query the actual interpreter when needed:
+IPi requires uv 0.12.3 or later. Initial startup includes a 180-second dependency preparation allowance in addition to the Jupyter readiness budget; `IPI_UV_BASE_ENVIRONMENT_TIMEOUT_S` changes that allowance for local and SSH launches. Select a project with `cwd` and use `additional_dependencies` for task requirements; explicit venv attachment is not supported. Native uv overlays let runtime and added packages override project pins inside the disposable kernel environment. Strict-lock mode checks the base lock, not the overlay versions. Personal defaults in `kernel.scratch_dependencies` and `publication.scratch_shared_dependencies` apply only outside a uv project. Live `%pip` changes are private to this kernel and do not change other kernels or later launches. The environment hint describes available modules and distribution/import aliases. Query the actual interpreter when needed:
 
 ```python
 import sys

{ipinb-0.2.0/docs → ipinb-0.3.0/ipi/skills/notebook/references}/kernel-environments.md

@@ -10,11 +10,11 @@ Reuse a suitable kernel ID already provided in context. When creating a kernel,
 create_kernel(cwd="/absolute/project", additional_dependencies=["numpy", "pandas"], request_id="analysis-kernel")
 ```
 
-The result may report `starting`. Python submitted with its returned `kernel_id` waits for setup. Inspect failed setup through the kernel record rather than assuming an accepted creation is ready. Configuration and plugins resolve for that kernel's cwd; a kernel created for another project can have a different environment.
+The result may report `starting`. Python submitted with its returned `kernel_id` waits for setup. Submit work with the returned ID and observe its cell; setup failures are returned directly even if setup failed before submission. Configuration and plugins resolve for that kernel's cwd; a kernel created for another project can have a different environment.
 
 IPi uses ephemeral `uv run --isolated` environments. uv selects the project or workspace member for `cwd`, its Python version, sources, and normal default dependency groups. IPi does not create or synchronize `.venv`. It resolves missing or stale locks temporarily without writing `uv.lock`; set `kernel.locked = true` in IPi configuration when a current lock is required. Approved direnv settings apply before resolution. IPi does not approve an `.envrc`.
 
-Added kernel dependencies must remain compatible with every package selected by the project. Conflicts fail without replacing those packages. Prefer `additional_dependencies` at creation for task requirements. Personal defaults in `kernel.scratch_dependencies` and `publication.scratch_shared_dependencies` apply only outside a uv project. An explicit `venv` selects an existing base without synchronizing it; it cannot be combined with locked project preparation. Live `%pip` changes are disposable. The environment hint describes available modules and distribution/import aliases. Query the actual interpreter when needed:
+IPi requires uv 0.12.3 or later. Initial startup includes a 180-second dependency preparation allowance in addition to the Jupyter readiness budget; `IPI_UV_BASE_ENVIRONMENT_TIMEOUT_S` changes that allowance for local and SSH launches. Select a project with `cwd` and use `additional_dependencies` for task requirements; explicit venv attachment is not supported. Native uv overlays let runtime and added packages override project pins inside the disposable kernel environment. Strict-lock mode checks the base lock, not the overlay versions. Personal defaults in `kernel.scratch_dependencies` and `publication.scratch_shared_dependencies` apply only outside a uv project. Live `%pip` changes are private to this kernel and do not change other kernels or later launches. The environment hint describes available modules and distribution/import aliases. Query the actual interpreter when needed:
 
 ```python
 import sys

{ipinb-0.2.0 → ipinb-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ipinb"
-version = "0.2.0"
+version = "0.3.0"
 description = "Persistent IPython notebooks for MCP agents"
 readme = "README.md"
 requires-python = ">=3.11"

{ipinb-0.2.0 → ipinb-0.3.0}/src/ipi/_transport/contract.py

@@ -23,7 +23,6 @@ class KernelLaunchRequest:
     """Validated target-side launch data, independent of one transport."""
 
     cwd: PurePath
-    venv: PurePath | None
     requirements: tuple[str, ...]
     environment: Mapping[str, str]
     locked: bool = False

{ipinb-0.2.0 → ipinb-0.3.0}/src/ipi/_transport/ssh.py

@@ -25,6 +25,7 @@ from typing import Any, cast
 from jupyter_client import KernelManager
 
 from ipi._exception_groups import BaseExceptionGroup
+from ipi._uv_environment import preparation_timeout_s
 from ipi.redaction import redact_exception_message, redact_url_secrets, redact_url_userinfo
 
 from .address import SshKernelLocation
@@ -587,7 +588,6 @@ class SshPreparedTransport:
             response = supervisor.request(
                 "launch",
                 cwd=request.cwd.as_posix(),
-                venv=(request.venv.as_posix() if request.venv is not None else None),
                 locked=request.locked,
                 requirements=list(request.requirements),
                 environment=dict(request.environment),
@@ -1487,14 +1487,13 @@ class _SupervisorClient:
         with self._request_lock:
             if self._closed:
                 raise SshTransportError("SSH supervisor control channel is closed")
+            timeout = _SUPERVISOR_RESPONSE_SECONDS
+            if operation == "launch":
+                preparation_timeout = preparation_timeout_s()
+                fields["preparation_timeout_s"] = preparation_timeout
+                timeout = _SUPERVISOR_LAUNCH_RESPONSE_SECONDS + preparation_timeout
             request_id = self._write_request(operation, fields=fields, one_way=False)
-            response = self._read_message(
-                timeout_s=(
-                    _SUPERVISOR_LAUNCH_RESPONSE_SECONDS
-                    if operation == "launch"
-                    else _SUPERVISOR_RESPONSE_SECONDS
-                )
-            )
+            response = self._read_message(timeout_s=timeout)
             if response.get("id") != request_id or response.get("version") != _PROTOCOL_VERSION:
                 raise SshTransportError("SSH supervisor returned a mismatched control response")
             if response.get("ok") is not True:

{ipinb-0.2.0 → ipinb-0.3.0}/src/ipi/_transport/supervisor.py

@@ -12,6 +12,7 @@ import base64
 import contextlib
 import ctypes
 import json
+import math
 import os
 import re
 import secrets
@@ -226,9 +227,14 @@ class Supervisor:
             cwd = _absolute_path(request.get("cwd"), what="kernel cwd")
             if not cwd.is_dir():
                 raise SupervisorError(f"kernel cwd does not exist or is not a directory: {cwd}")
-            venv_value = request.get("venv")
-            venv = None if venv_value is None else _absolute_path(venv_value, what="kernel venv")
-            _validate_requested_venv(venv)
+            preparation_timeout = request.get("preparation_timeout_s", 180.0)
+            if (
+                isinstance(preparation_timeout, bool)
+                or not isinstance(preparation_timeout, (int, float))
+                or not math.isfinite(preparation_timeout)
+                or preparation_timeout <= 0
+            ):
+                raise SupervisorError("preparation_timeout_s must be finite and positive")
             locked = request.get("locked", False)
             if not isinstance(locked, bool):
                 raise SupervisorError("locked must be a boolean")
@@ -266,7 +272,6 @@ class Supervisor:
                 session_dir=self._session_dir,
                 connection_file=self._connection_file,
                 cwd=cwd,
-                venv=venv,
                 locked=locked,
                 requirements=requirements,
                 environment=environment,
@@ -276,7 +281,6 @@ class Supervisor:
             ownership_manifest.write_text(
                 json.dumps(
                     {
-                        "external_venv": str(venv) if venv is not None else None,
                         "owned_environment": str(owned_environment),
                     },
                     sort_keys=True,
@@ -298,7 +302,7 @@ class Supervisor:
                     start_new_session=True,
                 )
 
-        connection = self._wait_for_connection()
+        connection = self._wait_for_connection(timeout_s=KERNEL_START_SECONDS + preparation_timeout)
         return {
             "ports": {
                 name: connection[name]
@@ -312,8 +316,8 @@ class Supervisor:
             }
         }
 
-    def _wait_for_connection(self) -> dict[str, object]:
-        deadline = time.monotonic() + KERNEL_START_SECONDS
+    def _wait_for_connection(self, *, timeout_s: float) -> dict[str, object]:
+        deadline = time.monotonic() + timeout_s
         while time.monotonic() < deadline:
             process = self._process
             if process is None:
@@ -344,7 +348,7 @@ class Supervisor:
                 return connection
             time.sleep(0.05)
         self._terminate_kernel(force=True)
-        raise SupervisorError("kernel did not bind its Jupyter ports within 120 seconds")
+        raise SupervisorError(f"kernel did not bind its Jupyter ports within {timeout_s:g} seconds")
 
     def _poll(self) -> int | None:
         process = self._process
@@ -582,7 +586,6 @@ def _kernel_launch_spec(
     session_dir: Path,
     connection_file: Path,
     cwd: Path,
-    venv: Path | None,
     requirements: tuple[str, ...],
     environment: Mapping[str, str],
     owner_marker: str,
@@ -598,7 +601,6 @@ def _kernel_launch_spec(
         uv=str(uv),
         cwd=cwd,
         directory=session_dir / "environment",
-        venv=venv,
         locked=locked,
         requirements=(str(wheel), *requirements),
         environment=child_env,
@@ -612,15 +614,6 @@ def _kernel_launch_spec(
     return command, prepared.environment, owned_environment
 
 
-def _validate_requested_venv(venv: Path | None) -> None:
-    if venv is None:
-        return
-    if not venv.is_dir() or not (venv / "pyvenv.cfg").is_file():
-        raise SupervisorError(
-            f"requested target virtual environment does not exist or is invalid: {venv}"
-        )
-
-
 def _remove_owned_session_dir(path: Path, *, expected: OwnedDirectoryIdentity) -> None:
     if not path.exists() and not path.is_symlink():
         return

{ipinb-0.2.0 → ipinb-0.3.0}/src/ipi/_uv_environment.py

@@ -1,14 +1,10 @@
-"""Resolve kernel environments through uv, with project packages as constraints.
-
-uv owns project and workspace discovery, Python selection, dependency groups,
-sources, and temporary environments. A base probe captures its exact selection;
-constraints prevent an additive overlay from replacing that selection.
-"""
+"""Launch private writable uv environments with native dependency overrides."""
 
 from __future__ import annotations
 
 import contextlib
 import json
+import math
 import os
 import shlex
 import shutil
@@ -20,39 +16,12 @@ from dataclasses import dataclass
 from pathlib import Path
 
 import tomllib
+from packaging.version import InvalidVersion, Version
 
 from ipi.redaction import redact_url_secrets
 from ipi.runtime.project import nearest_pyproject, read_project_name
 
-# Only the standard library is available in an arbitrary project interpreter.
-_PROBE = """
-import importlib.metadata as metadata
-import json, os, sys
-from urllib.parse import quote
-requirements = []
-for dist in metadata.distributions():
-    name = dist.metadata.get("Name")
-    if not name:
-        continue
-    value = name + "==" + dist.version
-    raw = dist.read_text("direct_url.json")
-    if raw:
-        direct = json.loads(raw)
-        url = direct["url"]
-        vcs = direct.get("vcs_info")
-        if vcs:
-            url = vcs["vcs"] + "+" + url + "@" + vcs["commit_id"]
-        if direct.get("subdirectory"):
-            url += ("&" if "#" in url else "#") + "subdirectory=" + quote(direct["subdirectory"])
-        value = name + " @ " + url
-    requirements.append(value)
-print(json.dumps({
-    "executable": os.path.realpath(sys.executable),
-    "prefix": sys.prefix,
-    "version": ".".join(map(str, sys.version_info[:3])),
-    "requirements": sorted(set(requirements)),
-}))
-"""
+MIN_UV_VERSION = Version("0.12.3")
 
 
 @dataclass(frozen=True)
@@ -67,8 +36,6 @@ class UvEnvironment:
     argv: list[str]
     environment: dict[str, str]
     project: UvProject | None
-    base_python: Path
-    base_prefix: Path
 
 
 def _environment(cwd: Path, environment: Mapping[str, str]) -> dict[str, str]:
@@ -93,8 +60,16 @@ def _environment(cwd: Path, environment: Mapping[str, str]) -> dict[str, str]:
     return dict(environment)
 
 
-def _run(cwd: Path, command: Sequence[str], environment: Mapping[str, str]) -> str:
+def preparation_timeout_s() -> float:
+    """Budget for cold resolution/builds, now part of the initial uv launch."""
     timeout = float(os.environ.get("IPI_UV_BASE_ENVIRONMENT_TIMEOUT_S", "") or 180)
+    if not math.isfinite(timeout) or timeout <= 0:
+        raise ValueError("IPI_UV_BASE_ENVIRONMENT_TIMEOUT_S must be finite and positive")
+    return timeout
+
+
+def _run(cwd: Path, command: Sequence[str], environment: Mapping[str, str]) -> str:
+    timeout = preparation_timeout_s()
     try:
         with subprocess.Popen(
             command,
@@ -146,6 +121,22 @@ def project_context(
     return _project_context(cwd, uv=uv, env=env)
 
 
+def _uv_program(cwd: Path, env: Mapping[str, str], uv: str | None) -> str:
+    program = uv or shutil.which("uv", path=env.get("PATH"))
+    if program is None:
+        raise RuntimeError(f"IPi requires uv >= {MIN_UV_VERSION} on PATH; install or upgrade uv")
+    reported = _run(cwd, [program, "--version"], env)
+    try:
+        installed = Version(reported.split()[1])
+    except (IndexError, InvalidVersion):
+        raise RuntimeError(f"Cannot determine uv version from {reported!r}; upgrade uv") from None
+    if installed < MIN_UV_VERSION:
+        raise RuntimeError(
+            f"IPi requires uv >= {MIN_UV_VERSION}; found {installed}. Upgrade uv before creating a kernel."
+        )
+    return program
+
+
 def _project_context(cwd: Path, *, uv: str | None, env: Mapping[str, str]) -> UvProject | None:
     selection_root = Path(env.get("UV_PROJECT") or cwd)
     if not selection_root.is_absolute():
@@ -160,9 +151,7 @@ def _project_context(cwd: Path, *, uv: str | None, env: Mapping[str, str]) -> Uv
         return None
     if "project" not in data and "workspace" not in uv_settings:
         return None
-    program = uv or shutil.which("uv", path=env.get("PATH"))
-    if program is None:
-        raise RuntimeError("uv is required on PATH to resolve IPi projects")
+    program = uv or _uv_program(cwd, env, None)
     common = [program, "--color", "never", "--directory", str(cwd), "workspace"]
     root = Path(_run(cwd, [*common, "dir"], env)).resolve()
     members = [
@@ -179,7 +168,6 @@ def prepare_environment(
     directory: Path,
     requirements: Sequence[str],
     editables: Sequence[str] = (),
-    venv: Path | None = None,
     locked: bool = False,
     uv: str | None = None,
     environment: Mapping[str, str] | None = None,
@@ -188,44 +176,22 @@ def prepare_environment(
     """Build one local or target-side uv command without writing project state."""
     env = _environment(cwd, os.environ if environment is None else environment)
     env.update(overrides or {})
-    program = uv or shutil.which("uv", path=env.get("PATH"))
-    if program is None:
-        raise RuntimeError("uv is required on PATH to launch IPi kernels")
+    program = _uv_program(cwd, env, uv)
     env.pop("UV_PROJECT_ENVIRONMENT", None)
     env.pop("VIRTUAL_ENV", None)
-    if locked and venv is not None:
-        raise ValueError("choose either an explicit venv or locked uv project preparation")
     project = _project_context(cwd, uv=program, env=env)
-    command = [program, "run", "--directory", str(cwd)]
-    if venv is not None:
-        env["VIRTUAL_ENV"] = str(venv)
-        command.extend(("--active", "--no-sync"))
-    else:
-        command.append("--isolated")
+    command = [program, "run", "--directory", str(cwd), "--isolated"]
     if project is None:
         command.append("--no-project")
     if locked:
         if project is None:
             raise ValueError("locked kernel preparation requires a uv project")
         command.append("--locked")
-    payload = json.loads(_run(cwd, [*command, "python", "-c", _PROBE], env).splitlines()[-1])
     directory.mkdir(parents=True, exist_ok=True)
-    constraints = directory / "project-constraints.txt"
-    constraints.write_text("\n".join(payload["requirements"]) + "\n")
     overlay = directory / "kernel-requirements.txt"
-    overlay.write_text(f"-c {constraints}\n" + "\n".join(requirements) + "\n")
-    # Preserve uv's Python choice across the probe and final launch. An explicit
-    # venv owns its interpreter and does not accept another Python selector.
-    if venv is None:
-        command.extend(("--python", payload["executable"]))
+    overlay.write_text("\n".join(requirements) + "\n")
     command.extend(("--with-requirements", str(overlay)))
     for editable in editables:
         command.extend(("--with-editable", editable))
     command.append("python")
-    return UvEnvironment(
-        command,
-        env,
-        project,
-        Path(payload["executable"]),
-        Path(payload["prefix"]),
-    )
+    return UvEnvironment(command, env, project)

{ipinb-0.2.0 → ipinb-0.3.0}/src/ipi/execution_models.py

@@ -40,7 +40,6 @@ class KernelRecord(Model):
     kernel_id: str
     state: KernelState
     cwd: str
-    venv: str | None
     additional_dependencies: list[str]
     created_at: float
     request_id: str | None

{ipinb-0.2.0 → ipinb-0.3.0}/src/ipi/kernel.py

@@ -53,10 +53,10 @@ from ipi._transport import (
     SshKernelLocation,
     display_path,
     host_artifact_root,
-    resolve_location_path,
 )
 from ipi._transport.local import LocalPreparedTransport
 from ipi._transport.ssh import SshPreparedTransport
+from ipi._uv_environment import preparation_timeout_s
 from ipi.plugins.catalog import KernelEnvironment
 from ipi.plugins.kernel import kernel_setup_code
 from ipi.redaction import (
@@ -574,7 +574,6 @@ class Kernel:
                 if self._transport_request is None:
                     self._transport_request = KernelLaunchRequest(
                         cwd=self._location.cwd,
-                        venv=self._launch_command.resolved_virtual_env,
                         requirements=self._extra_packages,
                         environment={},
                     )
@@ -612,7 +611,6 @@ class Kernel:
         cwd: str | Path | None = None,
         *,
         location: KernelLocation | None = None,
-        venv: str | Path | None = None,
         locked: bool = False,
         kernel_dir: str | Path | None = None,
         text_char_limit: int = DEFAULT_TEXT_CHAR_LIMIT,
@@ -630,7 +628,6 @@ class Kernel:
         return launch_kernel(
             cwd=cwd,
             location=location,
-            venv=venv,
             locked=locked,
             kernel_dir=kernel_dir,
             text_char_limit=text_char_limit,
@@ -1871,7 +1868,9 @@ class Kernel:
             with timed("kernel_launch", "kernel_ready"):
                 _wait_for_kernel_ready(
                     client,
-                    timeout_s=KERNEL_READY_TIMEOUT_S,
+                    # Local uv now resolves/builds in this process before Jupyter starts.
+                    timeout_s=KERNEL_READY_TIMEOUT_S
+                    + (0 if self._location.remote else preparation_timeout_s()),
                     alive=manager.is_alive,
                     abort=self._launch_abort,
                 )
@@ -3276,7 +3275,6 @@ def launch_kernel(
     cwd: str | Path | None = None,
     *,
     location: KernelLocation | None = None,
-    venv: str | Path | None = None,
     locked: bool = False,
     kernel_dir: str | Path | None = None,
     text_char_limit: int = DEFAULT_TEXT_CHAR_LIMIT,
@@ -3325,10 +3323,6 @@ def launch_kernel(
                 target_requirements,
                 runtime_root=prepared_transport.runtime_root,
             )
-            resolved_venv = resolve_location_path(
-                str(venv) if venv is not None else None,
-                location=location,
-            )
             launch_command = UvRunCommand(
                 argv=[],
                 env_delta={"PYDEVD_DISABLE_FILE_VALIDATION": "1"},
@@ -3336,7 +3330,7 @@ def launch_kernel(
                 project_root=None,
                 package_name=None,
                 resolved_python_executable=None,
-                resolved_virtual_env=resolved_venv,
+                resolved_virtual_env=None,
                 nearest_pyproject_path=None,
                 nearest_project_name=None,
                 workspace_root=None,
@@ -3344,9 +3338,6 @@ def launch_kernel(
             )
             transport_request = KernelLaunchRequest(
                 cwd=location.cwd,
-                venv=(
-                    PurePosixPath(resolved_venv.as_posix()) if resolved_venv is not None else None
-                ),
                 requirements=requirements,
                 environment={},
                 locked=locked,
@@ -3372,7 +3363,6 @@ def launch_kernel(
             launch_command = _build_uv_run_command(
                 cwd=resolved_cwd,
                 directory=resolved_kernel_dir / "environment",
-                venv=venv,
                 locked=locked,
                 environment=os.environ,
                 extra_packages=tuple(
@@ -3561,7 +3551,6 @@ def _build_uv_run_command(
     *,
     cwd: Path,
     directory: Path,
-    venv: str | Path | None,
     extra_packages: tuple[str, ...],
     editable_packages: tuple[str, ...] = (),
     locked: bool = False,
@@ -3569,7 +3558,6 @@ def _build_uv_run_command(
 ) -> UvRunCommand:
     from ipi._uv_environment import prepare_environment
 
-    active_virtual_env = _resolve_virtualenv_path(venv, cwd=cwd) if venv else None
     overlay_args = _ipi_overlay_args() + _kernel_overlay_args(
         extra_packages,
         editable_packages=editable_packages,
@@ -3578,7 +3566,6 @@ def _build_uv_run_command(
     prepared = prepare_environment(
         cwd=cwd,
         directory=directory,
-        venv=active_virtual_env,
         requirements=tuple(value for flag, value in pairs if flag == "--with"),
         editables=tuple(value for flag, value in pairs if flag == "--with-editable"),
         locked=locked,
@@ -3589,8 +3576,8 @@ def _build_uv_run_command(
     package_name = project.name if project else None
     nearest_path = project.member / "pyproject.toml" if project else None
     workspace_path = project.root if project and project.root != project.member else None
-    resolved_python_executable = prepared.base_python
-    resolved_virtual_env = active_virtual_env
+    resolved_python_executable = None
+    resolved_virtual_env = None
     env_delta = dict(prepared.environment)
     env_delta.update(
         _kernel_environment_env_delta(
@@ -4463,33 +4450,6 @@ def _preserve_ipi_view_state(memory_ipi_cells: list[Any], disk_cells: list[Any])
             _carry_over_view_state(cell, disk_cell)
 
 
-def _virtualenv_path(path: Path) -> Path:
-    if path.is_file():
-        path = path.parent.parent
-    _virtualenv_python_path(path)
-    return path.resolve(strict=False)
-
-
-def _resolve_virtualenv_path(venv: str | Path, *, cwd: Path) -> Path:
-    path = Path(venv).expanduser()
-    if not path.is_absolute():
-        path = cwd / path
-    return _virtualenv_path(path)
-
-
-def _virtualenv_python_path(path: Path) -> Path:
-    if path.is_file():
-        return path.resolve(strict=False)
-    for candidate in (
-        path / "bin" / "python",
-        path / "Scripts" / "python.exe",
-        path / "Scripts" / "python",
-    ):
-        if candidate.exists():
-            return candidate.resolve(strict=False)
-    raise RuntimeError(f"virtualenv at {path} does not contain a Python executable")
-
-
 def _collect_iopub_message(
     outputs: list[KernelOutput],
     msg: dict[str, Any],