@code-yeongyu/senpi 2026.7.25-2 → 2026.7.26

package/docs/grok-neo.md

@@ -0,0 +1,77 @@
+> senpi can wear a different chrome. Ask it to show you around.
+
+# Grok Neo Mode (Experimental)
+
+`--grok-neo` is an experimental alternative presentation ("chrome") for the standard interactive mode. It runs the same agent, tools, sessions, and keybindings as the classic TUI — only the visual layer changes.
+
+## How It Differs from the Classic TUI
+
+The classic TUI renders a bordered editor, a multi-line footer with token and cost details, and expandable tool executions. The grok chrome replaces that presentation with:
+
+- **Input card** — the editor sits inside a rounded card (`╭─╮` / `╰─╯` borders) with a themed interior background.
+- **Compact footer** — model and working directory only; the detailed token/cost readout is intentionally omitted.
+- **Welcome card** — startup shows the app name and version inside a bordered card.
+- **Single-line tool rows** — tool executions render as one-line rows with a stable guide column (`┃`) and a diamond marker (`◆`).
+- **Braille working indicator** — the spinner uses the braille frame `⠹`, tinted with the active theme's accent colour.
+
+All chrome colours resolve through tokens backed by the active theme, so the chrome stays coherent with `grok-day` and with custom themes.
+
+### Overlay Policy
+
+Overlay options control placement, sizing, visibility, and focus; they do not carry presentation colours. Existing modal components render their own borders from the active theme. A modal using the standard `DynamicBorder` therefore inherits the active `border` token (`#585858` under `grok-night`); components that explicitly request an accent border keep that component-specific choice. The modal colour is supplied by the active theme, not by a grok overlay-options seam.
+
+## Enabling the Mode
+
+The mode is gated behind an environment variable and is **off by default**:
+
+```bash
+export SENPI_ENABLE_GROK_NEO=1   # also accepts "true" or "yes"
+senpi --grok-neo
+```
+
+Or for a single run:
+
+```bash
+SENPI_ENABLE_GROK_NEO=1 senpi --grok-neo
+```
+
+Without the gate, `--grok-neo` is absent from `--help` and parses as an unknown extension flag, exactly as if the feature did not exist.
+
+## Themes
+
+Two built-in themes ship with the mode:
+
+- `grok-night` — dark palette (the fallback)
+- `grok-day` — light palette
+
+Theme selection follows one precedence rule: **an existing settings theme always wins.** `grok-night` is only an in-memory fallback used when no theme was ever chosen, and it is never written to `settings.json`. To use `grok-day` (or any other theme), select it explicitly via `/settings` or in `settings.json`:
+
+```json
+{
+  "theme": "grok-day"
+}
+```
+
+Once you select a theme it is persisted and takes precedence on every later launch.
+
+Modal and overlay components resolve their border through the normal theme `border` token. Both Grok themes map that token to the §Palette modal value, `#585858`; the input and card values remain available through the other schema border slots.
+
+Note that `--theme <path>` **registers** a theme file or directory as a resource; it does not select one. Selection always happens through `/settings` or `settings.json`.
+
+Senpi is a rebranded distribution, so its first-time setup is intentionally unavailable: that flow only runs for the official Pi package/app/config identity. A fresh `--grok-neo` launch therefore reaches the normal in-memory `grok-night` fallback directly; it does not show a Grok-specific setup or persist a theme.
+
+## Architecture: One Process
+
+`--grok-neo` runs **in-process**: the chrome is a presentation strategy inside the ordinary interactive mode, in the same senpi process. There is no separate binary and no daemon — unlike the retired `--neo`, which launched a Go TUI binary talking to senpi over a JSONL RPC daemon.
+
+For the Bun-compiled binary (`npm run build:binary`) this means one process and one deployable directory. `bun build --compile` produces a single `dist/pi` executable, and its runtime assets ship alongside it in `dist/`: theme JSON files, image assets, the photon WASM module, and the pty native addon. Native `.node` addons are **not** embedded by `bun build --compile`; the pty addon is resolved as a sidecar relative to the executable (`dist/native/prebuilds/<platform-arch>/`). So the honest claim is "one process, one deployable directory" — not one file.
+
+## Experimental Status
+
+The mode is experimental: it is gated off by default, and its visuals and behaviour may change between releases. The classic TUI is unchanged and remains the default.
+
+## Licence and Attribution
+
+This mode is an **independent reimplementation** inspired by the style and techniques of [grok-build](https://github.com/xai-org/grok-build). grok-build is licensed under Apache-2.0; regardless of what that licence permits, no grok-build code was copied or translated into this project. The colour palette is colour data measured from terminal captures, not copied code.
+
+This project is not affiliated with or endorsed by xAI.

package/docs/keybindings.md

@@ -89,7 +89,6 @@ Modifier combinations: `ctrl+shift+x`, `alt+ctrl+x`, `ctrl+shift+alt+x`, `ctrl+1
 | `app.editor.external` | `ctrl+g` | Open in external editor (`externalEditor`, `$VISUAL`, `$EDITOR`, Notepad on Windows, or `nano` elsewhere) |
 | `app.clipboard.pasteImage` | `ctrl+v` (`alt+v` on Windows) | Paste image from clipboard |
 | `app.history.search` | `ctrl+r` | Search prompt history across sessions |
-| `app.sessions.observe` | `ctrl+s` | Observe session transcripts |
 
 ### Sessions
 

package/docs/settings.md

@@ -212,9 +212,9 @@ Set `PI_SKIP_VERSION_CHECK=1` to disable the senpi version update check. Use `--
 | `retry.abortServerSideFallback` | boolean | `true` | Abort a turn when the provider substitutes a different model after a classifier decline |
 | `retry.provider.timeoutMs` | number | `300000` | Provider/SDK request timeout and stream idle timeout in milliseconds |
 | `retry.provider.maxRetries` | number | `0` | Provider/SDK retry attempts |
-| `retry.provider.maxRetryDelayMs` | number | `60000` | Max server-requested delay before failing (60s) |
+| `retry.provider.maxRetryDelayMs` | number | `60000` | Max server-requested delay honored on the same model before the fallback chain engages (60s) |
 
-When a provider requests a retry delay longer than `retry.provider.maxRetryDelayMs`, the request fails immediately with an informative error instead of waiting silently. Set it to `0` to disable the limit.
+A server-requested retry delay at or below `retry.provider.maxRetryDelayMs` is honored on the same model. A longer delay means the model is unavailable rather than busy, so Senpi engages the configured fallback chain instead of waiting, suppressing the primary for the requested duration; the turn fails with an informative error only when no chain candidate can take over.
 
 Keep `retry.provider.maxRetries` at `0` unless provider-level retries are explicitly needed. Setting it above `0` can make SDK/provider retries handle out-of-usage-limit errors before senpi sees them, which may block the agent until the provider quota resets in some circumstances.
 
@@ -257,7 +257,7 @@ A fallback entry with `:thinking-level` requests that level on the target model;
 
 #### Fallback behavior and diagnostics
 
-With `retry.enabled` and `retry.modelFallback` enabled, Senpi can switch from a transient or eligible hard provider failure to the next configured candidate. The switch continues the current turn without changing the existing conversation prefix, preserving prompt-cache inputs; fallback lifecycle events are never added to model context. Returning to a primary model happens only at a turn boundary, never while a response is streaming.
+With `retry.enabled` and `retry.modelFallback` enabled, Senpi can switch from a transient or eligible hard provider failure to the next configured candidate. Transient failures (timeouts, overload, 429, 5xx, transport drops) first retry the same model on the existing exponential backoff; the chain engages only after `retry.maxRetries` attempts are spent, and each fallback candidate starts with a fresh retry budget. Hard failures (quota, auth, model-not-found) and classifier refusals still switch immediately. The switch continues the current turn without changing the existing conversation prefix, preserving prompt-cache inputs; fallback lifecycle events are never added to model context. Returning to a primary model happens only at a turn boundary, never while a response is streaming. Selector cooldowns are error-derived, and a provider retry-after hint always wins: quota and billing failures park a model for 30 minutes, rate limits for 30 seconds, overload for 45 seconds plus jitter, 5xx for 20 seconds, and timeout or connection/transport failures for 60 seconds; unmatched failures default to five minutes. A fully failing chain costs up to `1 + (chainLength + 1) * maxRetries` provider calls plus per-rung backoff before the turn fails; with `maxRetries: 0` every failure switches immediately, costing `1 + chainLength` calls.
 
 Anthropic streaming refusals are identified from typed `stopDetails`. A configured candidate receives an immediate **pinned** fallback switch with a user-visible fallback notice: Senpi does not retry the refusing model and a pinned fallback never auto-reverts. Set `retry.fallbackRevertPolicy` to `"cooldown-expiry"` (the default) to return an unpinned fallback to its primary after the primary's cooldown expires, or `"never"` to keep the fallback until you change models.
 

package/docs/terminal-tools.md

@@ -11,7 +11,8 @@ platform/runtime).
 | Tool | Purpose |
 |------|---------|
 | `bash` | Run a command in a PTY. `run_in_background: true` starts a persistent session and returns a `bash_id` immediately. Foreground `timeout` (seconds) is a kill deadline. |
-| `bash_output` | Read new output from a session, or `wait_for` a regex / exit / timeout. `filter` regex-filters lines; `view: "screen"` returns the rendered xterm grid. |
+| `bash_output` | Peek at a session without blocking: new output since the last read, or the status line. `filter` regex-filters lines; `view: "screen"` returns the rendered xterm grid. |
+| `monitor` | Watch a long-running command (`description`, `command`, `filter?`, `timeout_ms?`, `persistent?`) and inject matching stdout lines as coalesced events. |
 | `bash_input` | Send stdin (`input`) or named keys (`keys: ["ctrl+c"]`, `["enter"]`, `["up"]`) to steer a REPL or interrupt a process. |
 | `bash_resize` | Resize a session's PTY (`cols`, `rows`) so full-screen TUIs reflow. |
 | `kill_bash` | Tree-kill one session (`bash_id`) or all (`all: true`), leaving no orphans. |
@@ -20,8 +21,10 @@ Background sessions are NEVER killed by `timeout` (they live until they exit or
 call `kill_bash`), even though the bash-timeout extension injects a default `timeout`
 into every `bash` call. Foreground calls behave like the classic `bash` tool.
 
-Typical flow: start with `run_in_background: true`, subscribe with `bash_output`
-(`wait_for`), steer with `bash_input`, then `kill_bash` when done.
+Typical flow: start with `run_in_background: true`, watch for patterns with `monitor`,
+peek with `bash_output`, steer with `bash_input`, then `kill_bash` when done. Completion
+arrives as a notification carrying the exit code and output tail, so a follow-up
+`bash_output` read is only needed when the tail is not enough.
 
 ## Mutual exclusion with native Anthropic bash
 

package/docs/usage.md

@@ -57,7 +57,7 @@ Type `/` in the editor to open command completion. Extensions can register custo
 | `/reload` | Reload keybindings, extensions, skills, prompts, themes, and context files |
 | `/hotkeys` | Show all keyboard shortcuts |
 | `/changelog` | Display version history |
-| `/quit` | Quit pi |
+| `/quit`, `/exit` | Quit pi |
 
 ## Message Queue
 

package/node_modules/@code-yeongyu/senpi-codemode/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [Unreleased]
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.7.26] - 2026-07-26
+
+### Breaking Changes
+
+- Remove the separate GPT-only `exec`/`wait` runtime; GPT models now compose active tools through the persistent `eval` surface.
+
+### Added
+
+- Detach interactive `eval` cells on timeout, inject completion notifications, and support `peek`/`stop` actions without blocking other language kernels.
+- Report whether Python kernel state survived an interrupt or timeout, with a real-surface QA driver covering the contract.
+
+### Changed
+
+- Bound each cell's retained status history and summarize omitted events ([#334](https://github.com/code-yeongyu/senpi/pull/334) by [@minpeter](https://github.com/minpeter)).
+- Make task-output lookups non-blocking and document detached-cell state, output, and artifact behavior.
+
+### Fixed
+
+- Preserve Python state when interruption succeeds, report truthful state when it does not, and tolerate kernels predating the interrupt-outcome contract.
+- Stop normal bridge-request completion from aborting still-running host tool calls.
+
+### Removed
+
 ## [2026.7.25-2] - 2026-07-25
 
 ### Breaking Changes

package/node_modules/@code-yeongyu/senpi-codemode/README.md

@@ -1,15 +1,19 @@
 # @code-yeongyu/senpi-codemode
 
 `@code-yeongyu/senpi-codemode` is Senpi's source-only Code Mode extension. It
-registers persistent-kernel `eval` for every eligible model and GPT-only
-`exec`/`wait` cells for bounded JavaScript orchestration. `eval` owns one
-persistent kernel per enabled language and re-registers at session start after
-configuration, interpreter availability, and active task-tool names are known.
+registers the persistent-kernel `eval` execution surface for every eligible
+model. `eval` owns one persistent kernel per enabled language and re-registers
+at session start after configuration, interpreter availability, and active
+task-tool names are known.
 
 ## Capabilities
 
 - Persistent JavaScript, Python, Ruby, and Julia cells. State survives later
   cells in the same language until reset, restart, or session disposal.
+- Timeout detachment for interactive `eval`: long pure-compute cells return a
+  handle and continue in their existing kernel. Completion is injected with the
+  final value/error and buffered output; use `eval({ action: "peek"|"stop",
+  cell_id })` to inspect or terminate a detached cell.
 - Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
 - Structured status events for file operations, environment access, phases,
   bridge activity, and delegated task progress.
@@ -20,8 +24,8 @@ configuration, interpreter availability, and active task-tool names are known.
   fallbacks.
 - JavaScript import rewriting for supported local modules and package imports
   in the persistent Node.js worker.
-- GPT Code Mode `exec`/`wait` cells use fresh JavaScript workers, can compose
-  active tools through `tools.<name>(args)`, and never replace `eval`.
+- GPT models receive a terse `eval` prompt dialect that prioritizes composing
+  active tools through `tool.<name>(args)` and documents detach-on-timeout.
 
 ## Kernels
 
@@ -68,13 +72,13 @@ Configuration is loaded in this order:
 | Key | Default | Effect |
 | --- | --- | --- |
 | `languages` | `py`/`js` enabled; `rb`/`jl` disabled | Selects desired languages before interpreter detection. |
-| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`. |
+| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`; interactive calls detach by default and print/json calls error. |
 | `parallelPoolWidth` | `4` | Maximum concurrent `parallel()` thunks. |
 | `taskTools.task` | `"task"` | Registered tool name used by `agent()`. |
 | `taskTools.output` | `"task_output"` | Registered tool name used by `output()`. |
 | `outputSink.headBytes` | `20480` | Bytes retained from the beginning of a middle-truncated preview; `0` disables it. |
 | `outputSink.maxColumns` | `768` | Maximum rendered output columns; `0` disables column clamping. |
-| `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. |
+| `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. Each cell retains at most 100 status rows; after overflow, one omitted-count row precedes the latest 99 events. |
 
 `SENPI_CODEMODE_PY`, `SENPI_CODEMODE_JS`, `SENPI_CODEMODE_RB`, and
 `SENPI_CODEMODE_JL` override the corresponding file setting. `1` or `true`
@@ -96,7 +100,7 @@ options object and asynchronous helpers are `await`-able.
 | `read(path, offset?, limit?)` | Reads text with 1-indexed line slicing. `local://` paths resolve under the session artifact root. |
 | `write(path, content)` | Creates parent directories and writes text. `local://` paths persist in the session artifact root. |
 | `env(key?, value?)` | Reads all kernel environment values, one value, or sets one value. |
-| `tool.<name>(args)` / `tools.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline. `tools` is the GPT Code Mode spelling. |
+| `tool.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline. |
 | `completion(prompt, model?, system?, schema?)` | Requests a one-shot host completion; `schema` asks the host to parse structured output. |
 | `agent(prompt, ...)` | Delegates to the configured active `taskTools.task` tool. Supports background handles and structured JSON results. |
 | `output(ids, format?, offset?, limit?)` | Delegates transcript retrieval to the configured active `taskTools.output` tool. |
@@ -105,13 +109,31 @@ options object and asynchronous helpers are `await`-able.
 | `log(message)` / `phase(title)` | Emits progress text and starts a status phase. |
 
 `agent()` is available only when the configured task tool is active in the
-session. `output()` similarly requires the configured task-output tool. Missing
-tools produce a clear availability error instead of importing an orchestration
-package. `agent()` delegates through the tool contract, so task-engine
-permissions, progress updates, and transcripts remain owned by that engine.
+session. `output()` similarly requires the configured task-output tool and
+returns immediately: a running task reports its current status, while completed
+tasks return the requested transcript. Missing tools produce a clear
+availability error instead of importing an orchestration package. `agent()`
+delegates through the tool contract, so task-engine permissions, progress
+updates, and transcripts remain owned by that engine.
 `isolated`, `apply`, and `merge` are accepted for compatibility but emit a
 warning because this task-engine integration has no isolation model.
 
+## Detached cells
+
+`eval` accepts `on_timeout: "detach"|"error"`. The default is `"detach"` in
+interactive TUI, RPC, and app-server sessions; print and JSON one-shot runs
+default to `"error"` so their result is never silently detached. A detached
+cell keeps only its own language kernel busy. A new same-language call returns
+a busy error with its cell id and output tail; calls in other languages continue
+normally. Do not re-run the cell.
+
+Use `eval({ action: "peek", cell_id })` for its state and buffered output, or
+`eval({ action: "stop", cell_id })` to cancel it. Python stop interrupts the
+existing kernel and preserves variables. JavaScript stop kills and restarts its
+worker, so JavaScript VM state is lost. Detached completion messages state when
+kernel variables are available to the next eval cell; oversized buffered output
+is written under the session local root and referenced as `local://…`.
+
 ## Output and artifacts
 
 Cell output is streamed while the cell runs. Large streams spill to an absolute
@@ -139,11 +161,9 @@ Session generations fence retired kernels and callbacks; each cell settles once
 across completion, errors, cancellation, timeout, bridge failure, or a kernel
 crash.
 
-GPT Code Mode is not an additional sandbox: it uses the same Node worker trust
-boundary as JavaScript `eval`. Its separate cell lifecycle exists so a yielded
-`exec` can be observed or terminated with `wait` without affecting persistent
-`eval` kernels. `eval`, `exec`, and `wait` are excluded from the nested tool
-namespace to prevent recursive Code Mode execution.
+GPT models use the same JavaScript `eval` worker trust boundary as other JavaScript cells;
+there is no separate execution runtime. `eval` is excluded from the nested tool
+namespace to prevent recursive execution.
 
 ## Validation
 
@@ -157,5 +177,5 @@ npm run check
 
 Direct real-surface QA drivers live in `scripts/qa-*.ts`: kernel cells
 (`qa-py-cell.ts`, `qa-js-cell.ts`, `qa-rb-cell.ts`, `qa-jl-cell.ts`), end-to-end
-extension execution (`qa-e2e-eval.ts`, `qa-gpt-code-mode.ts`), and renderer output
+extension execution (`qa-e2e-eval.ts`), and renderer output
 (`qa-render-dump.ts`).

package/node_modules/@code-yeongyu/senpi-codemode/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.7.25-2",
+	"version": "2026.7.26",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "7.29.7",
-		"@earendil-works/pi-ai": "^2026.7.25-2",
+		"@earendil-works/pi-ai": "^2026.7.26",
 		"typebox": "1.1.38"
 	},
 	"peerDependencies": {
 		"@code-yeongyu/senpi": "*"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.7.25-2"
+		"@code-yeongyu/senpi": "2026.7.26"
 	},
 	"keywords": [
 		"senpi",

package/node_modules/@code-yeongyu/senpi-codemode/src/bridge/http-server.ts

@@ -75,7 +75,12 @@ async function handleRequest(
 	options: BridgeServerOptions,
 ): Promise<void> {
 	const abortController = new AbortController();
-	request.on("close", () => abortController.abort());
+	// IncomingMessage "close" fires on normal message completion in Node >= 16,
+	// so premature disconnect must be detected on the response side instead:
+	// its "close" without a finished response means the connection died mid-call.
+	response.on("close", () => {
+		if (!response.writableFinished) abortController.abort();
+	});
 	if (request.method !== "POST") {
 		sendJson(response, 404, { ok: false, error: transportError("not_found", "Bridge route was not found") });
 		return;

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/output-bridge.ts

@@ -62,7 +62,6 @@ export async function runEvalOutput(args: unknown, options: RunEvalOutputOptions
 					{
 						...(id.startsWith("st_") ? { task_id: id } : { name: id }),
 						mode,
-						block: true,
 					},
 					options.signal === undefined ? undefined : { signal: options.signal },
 				);

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/eval-notifier.ts

@@ -0,0 +1,40 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { EvalDetachedCellNotification, EvalDetachedCellNotifier } from "../tool/detached-cell-manager.ts";
+
+const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
+
+export type EvalNotifyMode = "wake" | "next-turn" | "off";
+
+export interface EvalNotifierDeps {
+	readonly sendUserMessage: (content: string, options?: { deliverAs?: "steer" | "followUp" }) => void;
+	readonly getContext: () => ExtensionContext | undefined;
+	readonly getMode: () => EvalNotifyMode;
+}
+
+/** Session-scoped completion injector with the same no-spin guards as terminal notifications. */
+export class EvalNotifier implements EvalDetachedCellNotifier {
+	readonly #deps: EvalNotifierDeps;
+	readonly #notified = new Set<string>();
+
+	constructor(deps: EvalNotifierDeps) {
+		this.#deps = deps;
+	}
+
+	/** Starts a fresh session generation without suppressing reused tool-call ids. */
+	reset(): void {
+		this.#notified.clear();
+	}
+
+	notify(cells: readonly EvalDetachedCellNotification[]): void {
+		const mode = this.#deps.getMode();
+		if (mode === "off") return;
+		const ctx = this.#deps.getContext();
+		if (ctx === undefined || NON_INTERACTIVE_MODES.has(ctx.mode) || ctx.model === undefined) return;
+		const pending = cells.filter((cell) => !this.#notified.has(cell.cellId));
+		if (pending.length === 0) return;
+		for (const cell of pending) this.#notified.add(cell.cellId);
+		this.#deps.sendUserMessage(pending.map((cell) => cell.content).join("\n\n"), {
+			deliverAs: mode === "wake" ? "steer" : "followUp",
+		});
+	}
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -1,10 +1,9 @@
 import * as os from "node:os";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
-import { CodeModeSessionRuntime } from "./codemode/runtime.ts";
-import { type CodeModeTool, createCodeModeTools, isGptCodeModeModel } from "./codemode/tools.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
 import { defaultCodemodeSettings } from "./config/settings.ts";
+import { EvalNotifier } from "./extension/eval-notifier.ts";
 import {
 	createExecuteTool,
 	createRuntime,
@@ -13,6 +12,7 @@ import {
 } from "./extension/runtime-factory.ts";
 import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from "./extension/session-manager.ts";
 import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
+import { EvalDetachedCellManager } from "./tool/detached-cell-manager.ts";
 import { createEvalTool } from "./tool/eval-tool.ts";
 import { renderEvalCall, renderEvalResult } from "./tool/render.ts";
 
@@ -29,11 +29,11 @@ type CodemodeEvent = SessionLifecycleEvent | "model_select";
 
 export interface CodemodeExtensionAPI {
 	registerTool(tool: ReturnType<typeof createEvalTool>): void;
+	registerRemovedToolHint(name: string, hint: string): void;
 	on(event: CodemodeEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
 	executeTool: AgentExecuteTool;
 	getActiveTools(): string[];
-	setActiveTools?(toolNames: string[]): void | Promise<void>;
-	getAllTools?(): readonly { readonly name: string }[];
+	sendUserMessage(content: string, options?: { deliverAs?: "steer" | "followUp" }): void;
 }
 
 export interface SenpiCodemodeOptions {
@@ -43,19 +43,24 @@ export interface SenpiCodemodeOptions {
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
 
-type DynamicCodeModeExtensionAPI = CodemodeExtensionAPI & {
-	registerTool(tool: CodeModeTool): void;
-	setActiveTools(toolNames: string[]): void | Promise<void>;
-	getAllTools(): readonly { readonly name: string }[];
-};
-
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
 	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
-	let activeRuntime: (SessionRuntime & { readonly codeMode?: CodeModeSessionRuntime }) | undefined;
+	let activeRuntime: SessionRuntime | undefined;
 	let activeModelId: string | undefined;
-	const registerEvalForRuntime = (runtime: SessionRuntime, modelId: string | undefined): void => {
+	let activeContext: ExtensionContext | undefined;
+	let activeCells: EvalDetachedCellManager | undefined;
+	const notifier = new EvalNotifier({
+		sendUserMessage: (content, notifyOptions) => pi.sendUserMessage(content, notifyOptions),
+		getContext: () => activeContext,
+		getMode: () => "wake",
+	});
+	const registerEvalForRuntime = (
+		runtime: SessionRuntime,
+		modelId: string | undefined,
+		cellManager: EvalDetachedCellManager,
+	): void => {
 		pi.registerTool(
 			createEvalTool({
 				enabledLanguages: runtime.enabledLanguages,
@@ -65,6 +70,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				complete,
 				settings: runtime.settings,
 				artifactsDir: runtime.artifactsDir,
+				cellManager,
 				executionTracker: manager,
 				renderers,
 				spawns: runtime.spawns,
@@ -75,21 +81,13 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		);
 	};
 	const dropRuntime = async (): Promise<void> => {
-		const codeMode = activeRuntime?.codeMode;
+		const cells = activeCells;
 		activeRuntime = undefined;
 		activeModelId = undefined;
-		await Promise.all([manager.dispose(), codeMode?.dispose()]);
-	};
-	const activateCodeModeTools = async (runtime: CodeModeSessionRuntime): Promise<void> => {
-		if (!isDynamicCodeModeExtensionAPI(pi)) return;
-		const tools = createCodeModeTools({ runtime });
-		pi.registerTool(tools.exec);
-		pi.registerTool(tools.wait);
-		await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
-	};
-	const deactivateCodeModeTools = async (): Promise<void> => {
-		if (!isDynamicCodeModeExtensionAPI(pi)) return;
-		await pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "exec" && name !== "wait"));
+		activeCells = undefined;
+		await cells?.dispose();
+		activeContext = undefined;
+		await manager.dispose();
 	};
 	pi.registerTool(
 		createEvalTool({
@@ -99,71 +97,53 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			executeTool: createExecuteTool(pi),
 			complete,
 			settings: defaultCodemodeSettings,
+			cellManager: new EvalDetachedCellManager({ notifier }),
 			executionTracker: manager,
 			renderers,
 			hostLine: hostLine(),
 		}),
 	);
+	pi.registerRemovedToolHint(
+		"exec",
+		'exec was removed; use eval({ language: "js", code }) instead. Long eval cells detach on timeout and notify when complete.',
+	);
+	pi.registerRemovedToolHint(
+		"wait",
+		'wait was removed; detached eval cells notify when complete. Use eval({ action: "peek"|"stop", cell_id }) to inspect or stop one.',
+	);
 
 	pi.on("session_start", async (event, ctx) => {
-		const previousCodeMode = activeRuntime?.codeMode;
+		const previousCells = activeCells;
+		activeCells = undefined;
+		await previousCells?.dispose();
 		const generation = manager.beginReplacement();
 		const runtime = await createRuntime(pi, ctx, event, complete, options);
 		const replaced = await manager.replace(generation, runtime.manager);
 		if (!replaced) return;
-		await previousCodeMode?.dispose();
-		const codeMode = isGptCodeModeModel(ctx.model?.id)
-			? new CodeModeSessionRuntime({
-					sessionId: runtime.sessionId,
-					cwd: runtime.cwd,
-					parallelPoolWidth: runtime.parallelPoolWidth,
-					executeTool: runtime.executeTool,
-				})
-			: undefined;
-		activeRuntime = { ...runtime, ...(codeMode === undefined ? {} : { codeMode }) };
+		notifier.reset();
+		activeContext = ctx;
+		const cellManager = new EvalDetachedCellManager({ artifactsDir: runtime.artifactsDir, notifier });
+		activeCells = cellManager;
+		activeRuntime = runtime;
 		activeModelId = ctx.model?.id;
-		registerEvalForRuntime(activeRuntime, activeModelId);
-		if (codeMode) await activateCodeModeTools(codeMode);
-		else await deactivateCodeModeTools();
+		registerEvalForRuntime(runtime, activeModelId, cellManager);
 	});
 	pi.on("session_shutdown", async () => dropRuntime());
 	pi.on("session_before_switch", async () => dropRuntime());
 	pi.on("session_before_fork", async () => dropRuntime());
-	pi.on("model_select", async (event) => {
+	pi.on("model_select", async (event, ctx) => {
+		activeContext = ctx;
 		const runtime = activeRuntime;
 		if (runtime === undefined) return;
 		const modelId = modelIdFrom(event);
 		if (modelId === undefined || modelId === activeModelId) return;
 		activeModelId = modelId;
-		registerEvalForRuntime(runtime, modelId);
-		if (!isGptCodeModeModel(modelId)) {
-			const { codeMode, ...nextRuntime } = runtime;
-			await codeMode?.dispose();
-			activeRuntime = nextRuntime;
-			await deactivateCodeModeTools();
-			return;
-		}
-		if (runtime.codeMode) {
-			if (isDynamicCodeModeExtensionAPI(pi)) {
-				await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
-			}
-			return;
-		}
-		const codeMode = new CodeModeSessionRuntime({
-			sessionId: runtime.sessionId,
-			cwd: runtime.cwd,
-			parallelPoolWidth: runtime.parallelPoolWidth,
-			executeTool: runtime.executeTool,
-		});
-		activeRuntime = { ...runtime, codeMode };
-		await activateCodeModeTools(codeMode);
+		const cellManager = activeCells;
+		if (cellManager === undefined) return;
+		registerEvalForRuntime(runtime, modelId, cellManager);
 	});
 }
 
-function isDynamicCodeModeExtensionAPI(pi: CodemodeExtensionAPI): pi is DynamicCodeModeExtensionAPI {
-	return typeof pi.setActiveTools === "function" && typeof pi.getAllTools === "function";
-}
-
 function hostLine(): string {
 	const cpu = os.cpus()[0]?.model?.trim();
 	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`]

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/context-manager.ts

@@ -1,4 +1,5 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelInterruptHandle } from "../../tool/types.ts";
 import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
 import {
 	assertJavaScriptKernelOpen,
@@ -48,14 +49,16 @@ export class JavaScriptKernel {
 		return await promise;
 	}
 
-	async interrupt(reason = "interrupted"): Promise<void> {
+	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "interrupt");
 		const active = this.#runs.active;
 		const target = this.#runs.takeInterruptTarget();
-		if (!target) return;
+		if (!target) return { stateRetained: Promise.resolve(true) };
 		if (target === active) this.#clearTimeout();
 		this.#runs.settle(target, stoppedResult(target.input.cellId, `JS cell interrupted: ${reason}`));
 		await this.#restartAfterStop();
+		// A restart always replaces the worker VM, so no user global survives.
+		return { stateRetained: Promise.resolve(false) };
 	}
 
 	async reset(): Promise<void> {

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/py/kernel-contract.ts

@@ -29,4 +29,6 @@ export interface PendingRun {
 	timeoutTimer: NodeJS.Timeout | null;
 	escalationTimer?: NodeJS.Timeout;
 	interruptReason?: string;
+	/** Set while an interrupt outcome is pending; resolved once the kernel knows whether state survived. */
+	resolveStateRetained?: (retained: boolean) => void;
 }