ipinb 0.2.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,5 +1,19 @@
 # Breaking Changes
 
+## 2026-10-28: Registry-qualified handles (0.4.0)
+
+Public kernel and cell IDs now include a persisted nine-digit decimal registry prefix, for example `123456789k0` and `123456789c1`. Kernel inventory cursors include that prefix too. IDs and cursors belong to their issuing server; pass returned values unchanged. Independent servers no longer issue identical handles by construction, although a random prefix collision remains possible. MCP kernel directories use the qualified kernel ID. Internal numeric execution indices and low-level session helpers are unchanged.
+
+**Migration:** Bare `k0`/`c1` handles and old cursors are not supported. Start a fresh IPi server and use its returned IDs. If `server.registry_root` points to a database with retained unqualified IDs, choose a new directory; startup rejects the old registry and preserves its records. Keep that directory with the previous IPi version to inspect historical records. Existing servers retain their current behavior until stopped; live Python state cannot transfer to a replacement server.
+
+## 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.4.0}/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable user-facing changes are recorded here. Detailed API removals and
 migration steps are maintained in [BREAKING_CHANGES.md](BREAKING_CHANGES.md).
 
+## 0.4.0
+
+- Qualify public kernel and cell handles with a persisted nine-digit decimal registry prefix while retaining compact, never-reused counters. Kernel inventory cursors include the registry prefix too.
+- Explain server ownership in unknown-handle errors and notebook guidance. Cross-agent work goes through the agent that owns the notebook; there is no cross-server routing.
+- Breaking: bare handles and old cursors are no longer supported. Registries with retained unqualified IDs require a new registry directory; existing records are preserved for inspection with the previous version. See [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.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipinb
-Version: 0.2.0
+Version: 0.4.0
 Summary: Persistent IPython notebooks for MCP agents
 Author-email: Nima Shoghi <nimashoghi@gmail.com>
 License-Expression: MIT
@@ -104,7 +104,7 @@ Execution requires an explicit `kernel_id`. The default observation window is fi
 
 Managed kernels keep IPython history in memory because the notebook and registry are the durable execution record. Kernel creation is explicit, apart from optional discoverable startup prewarming. A closed or lost handle never creates a replacement.
 
-Handles are registry-local counters beginning with `k` for kernels and `c` for cells, such as `k0` and `c1`. Pass them unchanged to their originating registry; IDs are never reused within that registry. Tool responses provide one structured JSON payload with typed resource, handle, cell, inventory, or error envelopes. Output cursors belong to each reader. Large sources and events provide immutable MCP resource URIs and byte counts. Use `read_cell(..., include_artifact_metadata=True)` for artifact filesystem paths, SHA-256 checksums, and MIME types.
+Handles combine a persisted nine-digit decimal registry prefix with `k` or `c` and a durable counter, such as `123456789k0` and `123456789c1`. Pass them unchanged to their originating registry; IDs are never reused within that registry. Tool responses provide one structured JSON payload with typed resource, handle, cell, inventory, or error envelopes. Output cursors belong to each reader. Large sources and events provide immutable MCP resource URIs and byte counts. Use `read_cell(..., include_artifact_metadata=True)` for artifact filesystem paths, SHA-256 checksums, and MIME types.
 
 `ipython` returns its bounded cell record plus any images the cell displayed as MCP
 image content, so `plt.show()` is one step instead of a path the model has to
@@ -117,10 +117,10 @@ Each notebook runtime gets a new session. Local sessions are stored under:
 ```text
 <initial-cwd>/.agents/sessions/<session-id>/
   session.jsonl
-  kernels/k1/notebook.ipynb
-  kernels/k1/outputs/manifest.json
-  kernels/k1/outputs/c1/g-<sha256-prefix>/input.py
-  kernels/k1/outputs/c1/g-<sha256-prefix>/o1-stdout.txt
+  kernels/123456789k1/notebook.ipynb
+  kernels/123456789k1/outputs/manifest.json
+  kernels/123456789k1/outputs/c1/g-<sha256-prefix>/input.py
+  kernels/123456789k1/outputs/c1/g-<sha256-prefix>/o1-stdout.txt
 ```
 
 Every input and every retained Jupyter MIME output has a durable local
@@ -158,7 +158,7 @@ Kernels always write an archival `notebook.ipynb`. Publish a specific live
 notebook only when someone needs to open it:
 
 ```text
-publish(kernel_id="k1", cells={"c1": "Result"})
+publish(kernel_id=kernel_id, cells={cell_id: "Result"})
 ```
 
 The tool starts one private Notebook 7 child attached to the existing IPi
@@ -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.4.0}/README.md

@@ -61,7 +61,7 @@ Execution requires an explicit `kernel_id`. The default observation window is fi
 
 Managed kernels keep IPython history in memory because the notebook and registry are the durable execution record. Kernel creation is explicit, apart from optional discoverable startup prewarming. A closed or lost handle never creates a replacement.
 
-Handles are registry-local counters beginning with `k` for kernels and `c` for cells, such as `k0` and `c1`. Pass them unchanged to their originating registry; IDs are never reused within that registry. Tool responses provide one structured JSON payload with typed resource, handle, cell, inventory, or error envelopes. Output cursors belong to each reader. Large sources and events provide immutable MCP resource URIs and byte counts. Use `read_cell(..., include_artifact_metadata=True)` for artifact filesystem paths, SHA-256 checksums, and MIME types.
+Handles combine a persisted nine-digit decimal registry prefix with `k` or `c` and a durable counter, such as `123456789k0` and `123456789c1`. Pass them unchanged to their originating registry; IDs are never reused within that registry. Tool responses provide one structured JSON payload with typed resource, handle, cell, inventory, or error envelopes. Output cursors belong to each reader. Large sources and events provide immutable MCP resource URIs and byte counts. Use `read_cell(..., include_artifact_metadata=True)` for artifact filesystem paths, SHA-256 checksums, and MIME types.
 
 `ipython` returns its bounded cell record plus any images the cell displayed as MCP
 image content, so `plt.show()` is one step instead of a path the model has to
@@ -74,10 +74,10 @@ Each notebook runtime gets a new session. Local sessions are stored under:
 ```text
 <initial-cwd>/.agents/sessions/<session-id>/
   session.jsonl
-  kernels/k1/notebook.ipynb
-  kernels/k1/outputs/manifest.json
-  kernels/k1/outputs/c1/g-<sha256-prefix>/input.py
-  kernels/k1/outputs/c1/g-<sha256-prefix>/o1-stdout.txt
+  kernels/123456789k1/notebook.ipynb
+  kernels/123456789k1/outputs/manifest.json
+  kernels/123456789k1/outputs/c1/g-<sha256-prefix>/input.py
+  kernels/123456789k1/outputs/c1/g-<sha256-prefix>/o1-stdout.txt
 ```
 
 Every input and every retained Jupyter MIME output has a durable local
@@ -115,7 +115,7 @@ Kernels always write an archival `notebook.ipynb`. Publish a specific live
 notebook only when someone needs to open it:
 
 ```text
-publish(kernel_id="k1", cells={"c1": "Result"})
+publish(kernel_id=kernel_id, cells={cell_id: "Result"})
 ```
 
 The tool starts one private Notebook 7 child attached to the existing IPi
@@ -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.4.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.
@@ -115,7 +121,7 @@ Bash tool registration is process-wide and disabled by default. Set `IPI_MCP_ENA
 
 `ipython(kernel_id, code, yield_time_ms, request_id)` accepts work and optionally observes it. A zero observation window always returns a `handle`, including for a fast completed execution. Positive observations return a `cell` view with truthful queued, running, paused, succeeded, failed, interrupted, or lost state. Live debugger stops use `paused`; unhandled failures finish as `failed` while optionally retaining postmortem frames. An interruption request is independent of execution state.
 
-`read_cell(cell_id, yield_time_ms=0)` reads immediately by default and can wait up to 30 seconds for Python output or completion. Python replies omit source, origin, created_at, and request_id; Markdown remains immediate and includes its source and metadata. These fields remain stored internally, and Python source is available through `ipi://cells/{cell_id}/source`. It uses caller-owned output cursors such as `c1:17`. Kernel inventories use `k:<offset>` and cell inventories use `<kernel_id>:<offset>`; the identity binds each cursor to its resource and page type. Callers pass cursors unchanged. Terminal execution does not imply that the current page exhausts output. Repeated reads replay the same retained events; a later event increments the revision without reopening terminal execution. IOPub events are sequenced and persisted before response construction. Terminal completion waits for both the shell result and ordered idle message.
+`read_cell(cell_id, yield_time_ms=0)` reads immediately by default and can wait up to 30 seconds for Python output or completion. Python replies omit source, origin, created_at, and request_id; Markdown remains immediate and includes its source and metadata. These fields remain stored internally, and Python source is available through `ipi://cells/{cell_id}/source`. It uses caller-owned output cursors such as `123456789c1:17`. Kernel inventories use `<registry-prefix>k:<offset>` and cell inventories use `<kernel_id>:<offset>`; the identity binds each cursor to its resource and page type. Callers pass cursors unchanged. Terminal execution does not imply that the current page exhausts output. Repeated reads replay the same retained events; a later event increments the revision without reopening terminal execution. IOPub events are sequenced and persisted before response construction. Terminal completion waits for both the shell result and ordered idle message.
 
 Model-facing output pages contain ordered `blocks`. Adjacent stream events from the same stream are concatenated into a stdout or stderr text block without changing the retained log. Other events preserve their identity and content, including immutable artifact references. The page cursor records the next underlying event, not the next block. Byte limits are applied after this projection; joining never crosses a different stream or a non-stream event.
 
@@ -139,7 +145,7 @@ The notebook mirrors retained records without re-executing them. Cross-cell disp
 
 `markdown` appends prose with optional retry deduplication and returns only `{"kind":"markdown","cell_id":"..."}`. An identical retry returns the same receipt. Use `read_cell(cell_id)` to retrieve the retained prose and metadata. `publish(kernel_id, cells={cell_id: caption})` optionally highlights terminal Python cells in the full notebook without adding executions or rows. Selection is validated before changing presentation: every selected cell must be accessible, terminal, and belong to the named kernel. Omitted cells keep their existing highlights. Publication reconciles retained records before exposing the live sidecar; a notebook synchronization failure cannot silently become a successful stale publication. Archival records survive live-kernel close under the configured retention policy, which has no automatic record expiry by default.
 
-Kernel handles use an unpadded, zero-based counter (`k0`, `k1`, ...); cell handles use a one-based counter (`c1`, `c2`, ...). Both are scoped to one registry. Python, Bash, markdown, and browser executions share the cell counter across kernels, so a cell ID alone resolves its record. Allocation state lives in the same SQLite database as retained resources and is committed before acceptance, so closed or expired records, failed acceptance, and owner restarts cannot recycle handles. Existing retained IDs are not renamed. Independent registries may both contain `k0` and `c1`; callers must retain the originating registry context. Execution replies contain one structured JSON payload, with an explicitly empty text-content list. Image blocks use MCP content while their complete MIME events remain retrievable as artifacts, avoiding a base64 copy in JSON.
+Kernel handles combine a persisted nine-digit decimal registry prefix with an unpadded, zero-based counter (`123456789k0`, `123456789k1`, ...); cell handles use the same prefix and a one-based counter (`123456789c1`, `123456789c2`, ...). Each registry draws its prefix once, uniformly from 100000000 through 999999999, and stores it in SQLite metadata. Reopening the database preserves the prefix. Python, Bash, markdown, and browser executions share the cell counter across kernels, so a cell ID alone resolves its record. Allocation state lives in the same SQLite database as retained resources and is committed before acceptance, so closed or expired records, failed acceptance, and owner restarts cannot recycle handles. Registries with retained unqualified IDs are rejected at startup without discarding their records; use a fresh registry root after upgrading. Foreign handles fail local lookup unless two registries draw the same prefix. This is probabilistic separation: a particular independent pair collides with probability 1/900000000, independent of retained cell count. Prefix collisions across many registries follow the birthday bound, and matching counters can then alias. Prefixes are not authentication secrets. There is no cross-server routing; ask the owning agent to run follow-up work and return results. The prefix adds three tokens per ID under the measured o200k_base and cl100k_base encodings; counters keep growing without padding or wrapping. Execution replies contain one structured JSON payload, with an explicitly empty text-content list. Image blocks use MCP content while their complete MIME events remain retrievable as artifacts, avoiding a base64 copy in JSON.
 
 ## Plugin Lifecycle
 

{ipinb-0.2.0 → ipinb-0.4.0}/docs/debugging.md

@@ -3,8 +3,8 @@
 IPi exposes one optional-use debugger tool backed by IPython's Pdb engine:
 
 ```python
-ipdb(kernel_id="k0", cell_id="c7", command="where")
-ipdb(kernel_id="k0", command="break /absolute/path/model.py:42")
+ipdb(kernel_id=kernel_id, cell_id=cell_id, command="where")
+ipdb(kernel_id=kernel_id, command="break /absolute/path/model.py:42")
 ```
 
 Every call names a kernel. Add a cell ID for frame inspection, Python evaluation, or execution control. Omit the cell ID for kernel-wide breakpoint configuration and exception-stop policy. There is no active-target selector.
@@ -19,7 +19,7 @@ Use `where`, `up`, `down`, `args`, `p expression`, `pp expression`, `list`, or `
 
 Insert `breakpoint()` in a submitted cell or set a source breakpoint before running it. The cell reports `paused` and a source location. `step`, `next`, `return`, `until`, and `continue` use the real debugger engine. `quit` abandons that execution and unwinds its cleanup. Breakpoint configuration uses Pdb syntax, including `break`, `tbreak`, `condition`, `ignore`, `enable`, `disable`, and `clear`. Bare `clear` clears all breakpoints without prompting. Kernel-scoped source breakpoints should name a file and line; frame-relative expressions require a cell target.
 
-`ipdb(kernel_id="k0", command="exceptions raised")` stops when an exception is raised, before handling; this includes exceptions that user code may catch. `exceptions off` restores default postmortem-only behavior. Internal iteration termination is excluded from automatic raised-exception stops.
+`ipdb(kernel_id=kernel_id, command="exceptions raised")` stops when an exception is raised, before handling; this includes exceptions that user code may catch. `exceptions off` restores default postmortem-only behavior. Internal iteration termination is excluded from automatic raised-exception stops.
 
 A live pause occupies its subshell. Other subshells and debugger commands remain usable. A pause also stops other tasks on that subshell's event loop; shared locks and mutable objects retain their normal Python behavior. There is no process-wide freeze or ability to step inside native C/CUDA operations. Interrupts and abandonment can be delayed by blocking native code or user code that suppresses cancellation.
 

{ipinb-0.2.0/ipi/skills/notebook/references → ipinb-0.4.0/docs}/execution-and-results.md

@@ -1,12 +1,12 @@
 # Execution, results, and recovery
 
-Read this when work runs longer than one tool call, output is large, or a connection drops. For overlapping submissions, also read [Parallel execution](parallel-execution.md). Examples below are MCP tool calls; use returned IDs in place of illustrative IDs.
+Read this when work runs longer than one tool call, output is large, or a connection drops. For overlapping submissions, also read [Parallel execution](parallel-execution.md). Examples below are MCP tool calls; `kernel_id` and `cell_id` stand for exact handles returned by this server.
 
 ## Submit and observe
 
 ```python
-ipython(kernel_id="k0", code="result = expensive_calculation()", yield_time_ms=0, request_id="calculate-1")
-read_cell(cell_id="c1", yield_time_ms=10000)
+ipython(kernel_id=kernel_id, code="result = expensive_calculation()", yield_time_ms=0, request_id="calculate-1")
+read_cell(cell_id=cell_id, yield_time_ms=10000)
 ```
 
 A `handle` means accepted, not completed. `yield_time_ms` limits how long the caller observes; it does not limit execution. A cancelled or disconnected observer leaves accepted work owned by IPi. Keep the kernel and cell IDs, then observe that same cell rather than resubmitting its code.
@@ -25,10 +25,10 @@ Large source or output bodies supply immutable MCP resource URIs. Read the retur
 
 Supply `request_id` when creating a kernel, submitting Python or Markdown, or issuing a debugger command if a lost response would make repetition risky. Reuse that key with the same operation and payload to recover its accepted record. Reusing a key for a different payload is rejected. A fresh key requests fresh work and can repeat side effects. Optional Bash also supports request IDs when enabled.
 
-HTTP and stdio expose the same execution API. HTTP reconnection does not require a new kernel: retain the kernel ID and use `list_cells(kernel_id=...)` when cell records need recovery. Closed or lost kernels do not contain usable live Python state. Identifiers do not replace authentication.
+HTTP and stdio expose the same execution API. HTTP reconnection to the same server does not require a new kernel: retain the kernel ID and use `list_cells(kernel_id=...)` when cell records need recovery. Closed or lost kernels do not contain usable live Python state. Kernel and cell IDs belong to the IPi server that issued them; pass them unchanged. For another agent's notebook, ask that agent to run follow-up work and return results. Identifiers do not replace authentication.
 
 ## Cancellation and debugger state
 
-`interrupt(cell_id="c1")` requests cancellation of that execution only. Continue observing its outcome. Native blocking code, suppressed cancellation, and descendant activity can outlive the request. `close_kernel(kernel_id="k0")` discards the named kernel's live state; retained records remain available under the storage policy. Finishing an answer is not a reason to close a reusable kernel.
+`interrupt(cell_id=cell_id)` requests cancellation of that execution only. Continue observing its outcome. Native blocking code, suppressed cancellation, and descendant activity can outlive the request. `close_kernel(kernel_id=kernel_id)` discards the named kernel's live state; retained records remain available under the storage policy. Finishing an answer is not a reason to close a reusable kernel.
 
 A new ordinary submission to a kernel abandons existing live debugger pauses and discards existing postmortem inspection before admission. Recovering an existing execution retry key does not repeat that cleanup. See [Debugging](debugging.md) before choosing to resume or move on.

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

@@ -4,17 +4,17 @@ Read this when choosing a working directory, Python environment, dependency over
 
 ## Choose the execution environment
 
-Reuse a suitable kernel ID already provided in context. When creating a kernel, pass an existing absolute working directory:
+Reuse a suitable kernel ID returned by this IPi server. When creating a kernel, pass an existing absolute working directory:
 
 ```python
 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
@@ -42,7 +42,7 @@ Python imports, file access, and Bash commands run on the target. Do not substit
 The `bash` tool is disabled by default. Set `IPI_MCP_ENABLE_BASH_TOOL=1` before server startup to advertise it. When present:
 
 ```python
-bash(kernel_id="k0", cmd="pwd", yield_time_ms=0, request_id="inspect-directory")
+bash(kernel_id=kernel_id, cmd="pwd", yield_time_ms=0, request_id="inspect-directory")
 ```
 
 Bash runs in the selected kernel environment and follows Python's cell handles, observation, retries, and targeted cancellation. Read its retained output with `read_cell`. Like a new `ipython` submission, it moves on from existing debugger pauses in that kernel. For calculations that should reuse Python variables, imports, or live objects, use `ipython`.

{ipinb-0.2.0/ipi/skills/notebook/references → ipinb-0.4.0/docs}/notebook-publishing.md

@@ -4,7 +4,7 @@
 
 ## Contract
 
-- Use `publish(kernel_id="k0", cells={"c1": "Main result"})`. The optional mapping highlights terminal Python cells in the full live notebook. It never filters or reruns notebook content. All selected cells must belong to the named kernel.
+- Use `publish(kernel_id=kernel_id, cells={cell_id: "Main result"})`. The optional mapping highlights terminal Python cells in the full live notebook. It never filters or reruns notebook content. All selected cells must belong to the named kernel.
 - Null captions highlight without text. Omitted cells retain their existing highlights; omit the map to publish without changing presentation. Empty notebooks can be published.
 - The complete mapping is validated before presentation changes. Valid highlights are retained even if endpoint creation subsequently fails.
 - A successful call returns the complete

{ipinb-0.2.0/ipi/skills/notebook/references → ipinb-0.4.0/docs}/parallel-execution.md

@@ -9,8 +9,8 @@ Finish shared setup first: imports, function definitions, and any data both oper
 For example, suppose a completed setup cell defined `load_metadata()` and `summarize_metrics()`, and neither operation depends on or mutates the other's state. These are MCP tool calls, not Python to execute inside the kernel:
 
 ```python
-ipython(kernel_id="k0", code="metadata = load_metadata()", yield_time_ms=0)
-ipython(kernel_id="k0", code="metrics = summarize_metrics()", yield_time_ms=0)
+ipython(kernel_id=kernel_id, code="metadata = load_metadata()", yield_time_ms=0)
+ipython(kernel_id=kernel_id, code="metrics = summarize_metrics()", yield_time_ms=0)
 ```
 
 Use each returned cell ID to observe that operation:

{ipinb-0.2.0/src/ipi/resources/references → ipinb-0.4.0/docs}/rich-output.md

@@ -22,13 +22,13 @@ figure.savefig("result.png", dpi=200, bbox_inches="tight")
 display(figure)
 ```
 
-Use the optional `view_image(kernel_id="k0", path="result.png")` tool to inspect an existing PNG, JPEG, GIF, or WebP on the kernel's filesystem. Relative paths resolve under that kernel's cwd, including for SSH kernels. This reads an image; it does not execute a cell. If that tool is absent from the catalog, inspect through an available image-capable host surface or an appropriate IPython display.
+Use the optional `view_image(kernel_id=kernel_id, path="result.png")` tool to inspect an existing PNG, JPEG, GIF, or WebP on the kernel's filesystem. Relative paths resolve under that kernel's cwd, including for SSH kernels. This reads an image; it does not execute a cell. If that tool is absent from the catalog, inspect through an available image-capable host surface or an appropriate IPython display.
 
 ## Add prose and highlight results
 
 ```python
-markdown(kernel_id="k0", source="## Result\nThe experiment completed with the parameters below.")
-publish(kernel_id="k0", cells={"c7": "Main result", "c9": "Validation"})
+markdown(kernel_id=kernel_id, source="## Result\nThe experiment completed with the parameters below.")
+publish(kernel_id=kernel_id, cells={cell_id: "Main result", validation_cell_id: "Validation"})
 ```
 
 These are MCP calls. Markdown appends a notebook cell, including while Python runs. Publication highlights selected terminal Python cells in the full live notebook; it does not select a subset for export or rerun the code. Captions describe already-retained results. See [Notebook publishing](notebook-publishing.md) for URL lifetime and highlight updates.

{ipinb-0.2.0 → ipinb-0.4.0}/ipi/skills/notebook/SKILL.md

@@ -3,7 +3,9 @@ name: notebook
 description: Use persistent Python kernels for multi-step investigation, analysis, prototyping, and verification with reusable state and rich output.
 ---
 
-Reuse a suitable kernel ID already provided in context, or create a kernel for the required cwd and environment. Retain its `kernel_id` and pass it to submissions and notebook mutations. A starting kernel queues Python until setup completes.
+Reuse a suitable kernel ID returned by this IPi server, or create a kernel for the required cwd and environment. Retain its `kernel_id` and pass it to submissions and notebook mutations. A starting kernel queues Python until setup completes.
+
+Kernel and cell IDs belong to the IPi server that issued them; pass them unchanged. For another agent's notebook, ask that agent to run follow-up work and return results.
 
 Use IPi's native parallel execution for independent work: submit separate cells to the same kernel with `yield_time_ms=0` before waiting on their results. IPi schedules them in bounded subshells that share Python globals; no manual subshell setup is needed. Use distinct names or synchronization, and wait for prerequisite cells to succeed before submitting dependent code. Create another kernel when work needs isolated globals or incompatible process state. See [Parallel execution](references/parallel-execution.md) for submission patterns, shared-state constraints, and capacity handling.
 

{ipinb-0.2.0 → ipinb-0.4.0}/ipi/skills/notebook/references/debugging.md

@@ -3,8 +3,8 @@
 IPi exposes one optional-use debugger tool backed by IPython's Pdb engine:
 
 ```python
-ipdb(kernel_id="k0", cell_id="c7", command="where")
-ipdb(kernel_id="k0", command="break /absolute/path/model.py:42")
+ipdb(kernel_id=kernel_id, cell_id=cell_id, command="where")
+ipdb(kernel_id=kernel_id, command="break /absolute/path/model.py:42")
 ```
 
 Every call names a kernel. Add a cell ID for frame inspection, Python evaluation, or execution control. Omit the cell ID for kernel-wide breakpoint configuration and exception-stop policy. There is no active-target selector.
@@ -19,7 +19,7 @@ Use `where`, `up`, `down`, `args`, `p expression`, `pp expression`, `list`, or `
 
 Insert `breakpoint()` in a submitted cell or set a source breakpoint before running it. The cell reports `paused` and a source location. `step`, `next`, `return`, `until`, and `continue` use the real debugger engine. `quit` abandons that execution and unwinds its cleanup. Breakpoint configuration uses Pdb syntax, including `break`, `tbreak`, `condition`, `ignore`, `enable`, `disable`, and `clear`. Bare `clear` clears all breakpoints without prompting. Kernel-scoped source breakpoints should name a file and line; frame-relative expressions require a cell target.
 
-`ipdb(kernel_id="k0", command="exceptions raised")` stops when an exception is raised, before handling; this includes exceptions that user code may catch. `exceptions off` restores default postmortem-only behavior. Internal iteration termination is excluded from automatic raised-exception stops.
+`ipdb(kernel_id=kernel_id, command="exceptions raised")` stops when an exception is raised, before handling; this includes exceptions that user code may catch. `exceptions off` restores default postmortem-only behavior. Internal iteration termination is excluded from automatic raised-exception stops.
 
 A live pause occupies its subshell. Other subshells and debugger commands remain usable. A pause also stops other tasks on that subshell's event loop; shared locks and mutable objects retain their normal Python behavior. There is no process-wide freeze or ability to step inside native C/CUDA operations. Interrupts and abandonment can be delayed by blocking native code or user code that suppresses cancellation.
 

{ipinb-0.2.0/docs → ipinb-0.4.0/ipi/skills/notebook/references}/execution-and-results.md

@@ -1,12 +1,12 @@
 # Execution, results, and recovery
 
-Read this when work runs longer than one tool call, output is large, or a connection drops. For overlapping submissions, also read [Parallel execution](parallel-execution.md). Examples below are MCP tool calls; use returned IDs in place of illustrative IDs.
+Read this when work runs longer than one tool call, output is large, or a connection drops. For overlapping submissions, also read [Parallel execution](parallel-execution.md). Examples below are MCP tool calls; `kernel_id` and `cell_id` stand for exact handles returned by this server.
 
 ## Submit and observe
 
 ```python
-ipython(kernel_id="k0", code="result = expensive_calculation()", yield_time_ms=0, request_id="calculate-1")
-read_cell(cell_id="c1", yield_time_ms=10000)
+ipython(kernel_id=kernel_id, code="result = expensive_calculation()", yield_time_ms=0, request_id="calculate-1")
+read_cell(cell_id=cell_id, yield_time_ms=10000)
 ```
 
 A `handle` means accepted, not completed. `yield_time_ms` limits how long the caller observes; it does not limit execution. A cancelled or disconnected observer leaves accepted work owned by IPi. Keep the kernel and cell IDs, then observe that same cell rather than resubmitting its code.
@@ -25,10 +25,10 @@ Large source or output bodies supply immutable MCP resource URIs. Read the retur
 
 Supply `request_id` when creating a kernel, submitting Python or Markdown, or issuing a debugger command if a lost response would make repetition risky. Reuse that key with the same operation and payload to recover its accepted record. Reusing a key for a different payload is rejected. A fresh key requests fresh work and can repeat side effects. Optional Bash also supports request IDs when enabled.
 
-HTTP and stdio expose the same execution API. HTTP reconnection does not require a new kernel: retain the kernel ID and use `list_cells(kernel_id=...)` when cell records need recovery. Closed or lost kernels do not contain usable live Python state. Identifiers do not replace authentication.
+HTTP and stdio expose the same execution API. HTTP reconnection to the same server does not require a new kernel: retain the kernel ID and use `list_cells(kernel_id=...)` when cell records need recovery. Closed or lost kernels do not contain usable live Python state. Kernel and cell IDs belong to the IPi server that issued them; pass them unchanged. For another agent's notebook, ask that agent to run follow-up work and return results. Identifiers do not replace authentication.
 
 ## Cancellation and debugger state
 
-`interrupt(cell_id="c1")` requests cancellation of that execution only. Continue observing its outcome. Native blocking code, suppressed cancellation, and descendant activity can outlive the request. `close_kernel(kernel_id="k0")` discards the named kernel's live state; retained records remain available under the storage policy. Finishing an answer is not a reason to close a reusable kernel.
+`interrupt(cell_id=cell_id)` requests cancellation of that execution only. Continue observing its outcome. Native blocking code, suppressed cancellation, and descendant activity can outlive the request. `close_kernel(kernel_id=kernel_id)` discards the named kernel's live state; retained records remain available under the storage policy. Finishing an answer is not a reason to close a reusable kernel.
 
 A new ordinary submission to a kernel abandons existing live debugger pauses and discards existing postmortem inspection before admission. Recovering an existing execution retry key does not repeat that cleanup. See [Debugging](debugging.md) before choosing to resume or move on.

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

@@ -4,17 +4,17 @@ Read this when choosing a working directory, Python environment, dependency over
 
 ## Choose the execution environment
 
-Reuse a suitable kernel ID already provided in context. When creating a kernel, pass an existing absolute working directory:
+Reuse a suitable kernel ID returned by this IPi server. When creating a kernel, pass an existing absolute working directory:
 
 ```python
 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
@@ -42,7 +42,7 @@ Python imports, file access, and Bash commands run on the target. Do not substit
 The `bash` tool is disabled by default. Set `IPI_MCP_ENABLE_BASH_TOOL=1` before server startup to advertise it. When present:
 
 ```python
-bash(kernel_id="k0", cmd="pwd", yield_time_ms=0, request_id="inspect-directory")
+bash(kernel_id=kernel_id, cmd="pwd", yield_time_ms=0, request_id="inspect-directory")
 ```
 
 Bash runs in the selected kernel environment and follows Python's cell handles, observation, retries, and targeted cancellation. Read its retained output with `read_cell`. Like a new `ipython` submission, it moves on from existing debugger pauses in that kernel. For calculations that should reuse Python variables, imports, or live objects, use `ipython`.

{ipinb-0.2.0/src/ipi/resources → ipinb-0.4.0/ipi/skills/notebook}/references/notebook-publishing.md

@@ -4,7 +4,7 @@
 
 ## Contract
 
-- Use `publish(kernel_id="k0", cells={"c1": "Main result"})`. The optional mapping highlights terminal Python cells in the full live notebook. It never filters or reruns notebook content. All selected cells must belong to the named kernel.
+- Use `publish(kernel_id=kernel_id, cells={cell_id: "Main result"})`. The optional mapping highlights terminal Python cells in the full live notebook. It never filters or reruns notebook content. All selected cells must belong to the named kernel.
 - Null captions highlight without text. Omitted cells retain their existing highlights; omit the map to publish without changing presentation. Empty notebooks can be published.
 - The complete mapping is validated before presentation changes. Valid highlights are retained even if endpoint creation subsequently fails.
 - A successful call returns the complete

{ipinb-0.2.0/src/ipi/resources → ipinb-0.4.0/ipi/skills/notebook}/references/parallel-execution.md

@@ -9,8 +9,8 @@ Finish shared setup first: imports, function definitions, and any data both oper
 For example, suppose a completed setup cell defined `load_metadata()` and `summarize_metrics()`, and neither operation depends on or mutates the other's state. These are MCP tool calls, not Python to execute inside the kernel:
 
 ```python
-ipython(kernel_id="k0", code="metadata = load_metadata()", yield_time_ms=0)
-ipython(kernel_id="k0", code="metrics = summarize_metrics()", yield_time_ms=0)
+ipython(kernel_id=kernel_id, code="metadata = load_metadata()", yield_time_ms=0)
+ipython(kernel_id=kernel_id, code="metrics = summarize_metrics()", yield_time_ms=0)
 ```
 
 Use each returned cell ID to observe that operation:

{ipinb-0.2.0/docs → ipinb-0.4.0/ipi/skills/notebook/references}/rich-output.md

@@ -22,13 +22,13 @@ figure.savefig("result.png", dpi=200, bbox_inches="tight")
 display(figure)
 ```
 
-Use the optional `view_image(kernel_id="k0", path="result.png")` tool to inspect an existing PNG, JPEG, GIF, or WebP on the kernel's filesystem. Relative paths resolve under that kernel's cwd, including for SSH kernels. This reads an image; it does not execute a cell. If that tool is absent from the catalog, inspect through an available image-capable host surface or an appropriate IPython display.
+Use the optional `view_image(kernel_id=kernel_id, path="result.png")` tool to inspect an existing PNG, JPEG, GIF, or WebP on the kernel's filesystem. Relative paths resolve under that kernel's cwd, including for SSH kernels. This reads an image; it does not execute a cell. If that tool is absent from the catalog, inspect through an available image-capable host surface or an appropriate IPython display.
 
 ## Add prose and highlight results
 
 ```python
-markdown(kernel_id="k0", source="## Result\nThe experiment completed with the parameters below.")
-publish(kernel_id="k0", cells={"c7": "Main result", "c9": "Validation"})
+markdown(kernel_id=kernel_id, source="## Result\nThe experiment completed with the parameters below.")
+publish(kernel_id=kernel_id, cells={cell_id: "Main result", validation_cell_id: "Validation"})
 ```
 
 These are MCP calls. Markdown appends a notebook cell, including while Python runs. Publication highlights selected terminal Python cells in the full live notebook; it does not select a subset for export or rerun the code. Captions describe already-retained results. See [Notebook publishing](notebook-publishing.md) for URL lifetime and highlight updates.

{ipinb-0.2.0 → ipinb-0.4.0}/ipi/skills/notebook-http/SKILL.md

@@ -3,6 +3,6 @@ name: notebook-http
 description: Use IPi's explicit persistent kernels across reconnecting HTTP MCP clients.
 ---
 
-HTTP and stdio expose the same IPi tools and resource IDs. Follow the notebook skill. Retain `kernel_id` for submissions and notebook mutations, and `cell_id` for observation and interruption. HTTP transport sessions do not own Python state; reconnecting does not require a new kernel. Resource IDs identify records and do not replace authentication.
+HTTP and stdio expose the same IPi tools and resource IDs. Follow the notebook skill. Retain `kernel_id` for submissions and notebook mutations, and `cell_id` for observation and interruption. HTTP transport sessions do not own Python state; reconnecting to the same server does not require a new kernel. IDs from another server are not portable; ask the owning agent to return results. Resource IDs identify records and do not replace authentication.
 
 There is no separate logical `session_id`, active-kernel selector, or whole-service kill tool. `close_kernel` ends only its named kernel. Published notebooks remain live until that kernel or the owning IPi process ends; retained records survive under the advertised storage policy.

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

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

{ipinb-0.2.0 → ipinb-0.4.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.4.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: