@code-yeongyu/senpi-codemode 2026.7.25-2 → 2026.7.28

package/src/index.ts

@@ -1,10 +1,10 @@
 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 { EvalSchemaToolInfo } from "./bridges/schema-bridge.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 +13,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 +30,12 @@ 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 }[];
+	getAllTools(): readonly EvalSchemaToolInfo[];
+	sendUserMessage(content: string, options?: { deliverAs?: "steer" | "followUp" }): void;
 }
 
 export interface SenpiCodemodeOptions {
@@ -43,28 +45,35 @@ 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,
 				kernelManager: manager,
 				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
 				executeTool: runtime.executeTool,
+				listTools: () => pi.getAllTools(),
 				complete,
 				settings: runtime.settings,
 				artifactsDir: runtime.artifactsDir,
+				cellManager,
 				executionTracker: manager,
 				renderers,
 				spawns: runtime.spawns,
@@ -75,21 +84,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({
@@ -97,73 +98,56 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			kernelManager: manager,
 			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
 			executeTool: createExecuteTool(pi),
+			listTools: () => pi.getAllTools(),
 			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/src/kernels/jl/prelude.jl

@@ -194,6 +194,12 @@ function completion(prompt::AbstractString; model="default", system=nothing, sch
     get(response, "text", response)
 end
 
+function tool_schema(name=nothing)
+    arguments = Dict{String, Any}()
+    name !== nothing && (arguments["name"] = string(name))
+    senpi_with_bridge_timeout_pause(() -> senpi_call_tool("__schema__", arguments))
+end
+
 function output(ids...; format="raw", offset=nothing, limit=nothing)
     isempty(ids) && error("At least one output ID is required")
     format in ("raw", "tail") || error("output() format must be 'raw' or 'tail'")

package/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/src/kernels/js/local-module-loader.ts

@@ -4,6 +4,7 @@ import type { BridgeConnectionConfig } from "../../bridge/protocol.ts";
 import {
 	RESERVED_AGENT_TOOL,
 	RESERVED_OUTPUT_TOOL,
+	RESERVED_SCHEMA_TOOL,
 	TIMEOUT_PAUSE_OP,
 	TIMEOUT_RESUME_OP,
 } from "../../bridge/reserved.ts";
@@ -33,6 +34,7 @@ type RuntimeModuleContext = {
 	readonly cwdUrl: string;
 	readonly localRootUrls: Readonly<Record<string, string>>;
 	readonly reservedAgentTool: string;
+	readonly reservedSchemaTool: string;
 	readonly reservedOutputTool: string;
 	readonly timeoutPauseOp: string;
 	readonly timeoutResumeOp: string;
@@ -55,6 +57,7 @@ function runtimeContext(options: LocalModuleLoaderOptions): RuntimeModuleContext
 		localRootUrls: roots,
 		reservedAgentTool: RESERVED_AGENT_TOOL,
 		reservedOutputTool: RESERVED_OUTPUT_TOOL,
+		reservedSchemaTool: RESERVED_SCHEMA_TOOL,
 		timeoutPauseOp: TIMEOUT_PAUSE_OP,
 		timeoutResumeOp: TIMEOUT_RESUME_OP,
 	};
@@ -66,6 +69,7 @@ function loaderPrelude(context: RuntimeModuleContext): string {
 		`globalThis.__senpi_module_context__ = ${serialized};`,
 		"globalThis.__senpi_reserved_agent_tool__ = globalThis.__senpi_module_context__.reservedAgentTool;",
 		"globalThis.__senpi_reserved_output_tool__ = globalThis.__senpi_module_context__.reservedOutputTool;",
+		"globalThis.__senpi_reserved_schema_tool__ = globalThis.__senpi_module_context__.reservedSchemaTool;",
 		"globalThis.__senpi_timeout_pause_op__ = globalThis.__senpi_module_context__.timeoutPauseOp;",
 		"globalThis.__senpi_timeout_resume_op__ = globalThis.__senpi_module_context__.timeoutResumeOp;",
 		"globalThis.__senpi_import__ = async (source, options) => {",

package/src/kernels/js/worker-runtime.js

@@ -50,6 +50,7 @@ export class JsWorkerRuntime {
 		globalThis.read = async (path, options, ...rest) => await this.#read(path, helperOptions("read", options, rest));
 		globalThis.write = async (path, content) => await this.#write(path, content);
 		globalThis.output = async (...args) => await this.#output(args);
+		globalThis.tool_schema = async name => await this.#toolSchema(name);
 		globalThis.agent = async (prompt, options, ...rest) => await this.#agent(prompt, options, rest);
 		globalThis.parallel = async thunks => await this.#parallel(thunks);
 		globalThis.pipeline = async (items, ...stages) => await this.#pipeline(items, stages);
@@ -250,6 +251,11 @@ export class JsWorkerRuntime {
 		return node;
 	}
 
+	async #toolSchema(name) {
+		const args = name === undefined || name === null ? {} : { name: String(name) };
+		return await this.#callTool(reservedTool("__senpi_reserved_schema_tool__", "tool_schema"), args);
+	}
+
 	async #callTool(toolName, args) {
 		const hooks = this.#hooks;
 		if (!hooks) throw new Error("tool call outside active JS cell");

package/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;
 }

package/src/kernels/py/kernel.ts

@@ -1,3 +1,4 @@
+import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { PendingRun, PythonKernelRunOptions, PythonKernelStartOptions, ResultMessage } from "./kernel-contract.ts";
 import { failedPythonResult, PythonKernelTransport } from "./transport.ts";
 
@@ -41,7 +42,7 @@ export class PythonKernel {
 		});
 	}
 
-	async interrupt(reason = "interrupted"): Promise<void> {
+	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
 		if (this.#failure) throw this.#failure;
 		for (const pending of [...this.#queue]) {
 			pending.interruptReason = reason;
@@ -49,7 +50,8 @@ export class PythonKernel {
 		}
 		const active = this.#active;
 		const transport = this.#transport;
-		if (!active || !transport || active.interruptReason !== undefined) return;
+		if (!active || !transport || active.interruptReason !== undefined)
+			return { stateRetained: Promise.resolve(true) };
 		active.interruptReason = reason;
 		if (active.timeoutTimer) clearTimeout(active.timeoutTimer);
 		active.timeoutTimer = null;
@@ -57,7 +59,11 @@ export class PythonKernel {
 			() => void this.#escalateInterruptedRun(active).catch(() => undefined),
 			interruptEscalationMs,
 		);
+		const stateRetained = new Promise<boolean>((resolve) => {
+			active.resolveStateRetained = resolve;
+		});
 		transport.interrupt(reason);
+		return { stateRetained };
 	}
 
 	async reset(): Promise<void> {
@@ -187,13 +193,18 @@ export class PythonKernel {
 		if (this.#transport !== transport) return;
 		const pending = this.#pending.get(result.cellId);
 		if (pending) this.#settleRun(pending, result);
+		// A result frame from the live runner proves the process survived the interrupt.
+		if (pending?.resolveStateRetained) pending.resolveStateRetained(true);
 	}
 
 	#onExit(transport: PythonKernelTransport, error: Error): void {
 		if (this.#transport !== transport) return;
 		this.#transport = null;
 		const active = this.#active;
-		if (active) this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		if (active) {
+			if (active.resolveStateRetained) active.resolveStateRetained(false);
+			this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		}
 		this.#startNext();
 	}
 
@@ -209,7 +220,10 @@ export class PythonKernel {
 			},
 		);
 		const active = this.#active;
-		if (active) this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		if (active) {
+			if (active.resolveStateRetained) active.resolveStateRetained(false);
+			this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		}
 	}
 
 	#settleRun(pending: PendingRun, result: ResultMessage): void {
@@ -258,6 +272,7 @@ export class PythonKernel {
 	async #escalateInterruptedRun(pending: PendingRun): Promise<void> {
 		if (this.#active !== pending || pending.interruptReason === undefined) return;
 		const transport = this.#transport;
+		if (pending.resolveStateRetained) pending.resolveStateRetained(false);
 		if (transport) await this.#beginRetirement(transport);
 		if (this.#pending.has(pending.input.cellId))
 			this.#settleRun(pending, failedPythonResult(pending.input.cellId, "Eval interrupted"));

package/src/kernels/py/prelude.py

@@ -12,6 +12,7 @@ import json
 import locale
 import os
 import re
+import signal
 import subprocess
 import sys
 import time
@@ -36,6 +37,7 @@ EMIT_LOCK = Lock()
 # Mirrors src/bridge/reserved.ts; this standalone subprocess asset cannot import TypeScript.
 RESERVED_AGENT_TOOL = "__agent__"
 RESERVED_OUTPUT_TOOL = "__output__"
+RESERVED_SCHEMA_TOOL = "__schema__"
 TIMEOUT_PAUSE_OP = "timeout-pause"
 TIMEOUT_RESUME_OP = "timeout-resume"
 
@@ -373,6 +375,14 @@ def completion(
     return response.get("text", response)
 
 
+def tool_schema(name: str | None = None) -> Any:
+    args: dict[str, Any] = {} if name is None else {"name": name}
+    return bridge_post(
+        "/call",
+        {"callId": f"py-{uuid.uuid4()}", "toolName": RESERVED_SCHEMA_TOOL, "args": args},
+    )
+
+
 def output(
     *ids: str,
     format: str = "raw",
@@ -843,6 +853,7 @@ USER_NS.update(
         "completion": completion,
         "agent": agent,
         "output": output,
+        "tool_schema": tool_schema,
         "__senpi_magic": _magic,
         "__senpi_magic_cell": _magic_cell,
         "__senpi_shell": _shell,
@@ -886,6 +897,9 @@ def run_cell(cell_id: str, code: str) -> None:
     start = time.monotonic()
     stdout = io.StringIO()
     stderr = io.StringIO()
+    # SIGINT must interrupt user code here; the idle baseline (set between
+    # cells) ignores it so a late signal cannot kill the stdin-read loop.
+    signal.signal(signal.SIGINT, signal.default_int_handler)
     try:
         with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
             body, expression = compile_cell(code)
@@ -914,6 +928,8 @@ def run_cell(cell_id: str, code: str) -> None:
                 "durationMs": elapsed(start),
             }
         )
+    finally:
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
 
 
 def elapsed(start: float) -> int:
@@ -942,6 +958,7 @@ def handle(message: dict[str, Any]) -> bool:
 
 
 def main() -> None:
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
     for raw in sys.stdin:
         try:
             if not handle(json.loads(raw)):

package/src/kernels/rb/prelude.rb

@@ -5,6 +5,7 @@ require "uri"
 
 SENPI_RESERVED_AGENT_TOOL = "__agent__"
 SENPI_RESERVED_OUTPUT_TOOL = "__output__"
+SENPI_RESERVED_SCHEMA_TOOL = "__schema__"
 SENPI_INTERNAL_URL = Regexp.new("\\A([a-z][a-z0-9+.\\-]*)://(.*)\\z", Regexp::IGNORECASE)
 
 def __senpi_status_enabled?
@@ -187,6 +188,11 @@ def completion(prompt, model: "default", system: nil, schema: nil, **kwargs)
   result.fetch("text", result)
 end
 
+def tool_schema(name = nil)
+  args = name.nil? ? {} : { "name" => name.to_s }
+  __senpi_call_tool(SENPI_RESERVED_SCHEMA_TOOL, args)
+end
+
 def output(*ids, format: "raw", offset: nil, limit: nil)
   raise ArgumentError, "At least one output ID is required" if ids.empty?
   raise ArgumentError, "output() format must be 'raw' or 'tail'" unless ["raw", "tail"].include?(format)

package/src/kernels/shared/subprocess-kernel.ts

@@ -1,5 +1,6 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
 import { SubprocessRunQueue } from "./subprocess-queue.ts";
@@ -44,24 +45,26 @@ export class SubprocessKernel {
 		return run;
 	}
 
-	async interrupt(reason = "interrupted"): Promise<void> {
-		if (this.closed) return;
+	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
+		if (this.closed) return { stateRetained: Promise.resolve(true) };
 		if (!this.runs.active) {
-			if (!this.retirementPromise) return;
+			if (!this.retirementPromise) return { stateRetained: Promise.resolve(true) };
 			const queued = this.runs.takeWaiting();
 			if (queued) this.runs.settle(queued, failureResult(queued, new CellInterruptedError(reason)));
-			return;
+			return { stateRetained: Promise.resolve(true) };
 		}
 		const process = this.process;
 		process?.retire();
 		this.runs.clearToolCalls();
 		const run = this.runs.active;
-		if (!run) return;
+		if (!run) return { stateRetained: Promise.resolve(true) };
 		this.runs.releaseActive(run);
 		this.runs.settle(run, failureResult(run, new CellInterruptedError(reason)));
 		const signal = globalThis.process.platform === "win32" ? "SIGTERM" : "SIGINT";
 		await this.restartProcess(process, signal, 5_000);
 		if (this.failure) throw this.failure;
+		// Restart always spawns a fresh interpreter, so no user global survives.
+		return { stateRetained: Promise.resolve(false) };
 	}
 
 	nextToolCall(): Promise<ToolCallMessage> {

package/src/prompt/eval-prompt.ts

@@ -21,7 +21,7 @@ export interface EvalPromptOptions {
 }
 
 /** Prompt dialect for the eval-first batching emphasis. */
-export type EvalEmphasisStyle = "default" | "claude" | "codex" | "kimi";
+export type EvalEmphasisStyle = "default" | "claude" | "codex" | "gpt" | "kimi";
 
 const CLAUDE_MODEL_RE = /(^|[/.:])claude[-.]/i;
 const GLM_MODEL_RE = /(^|[/.:@-])glm[-.]?\d/i;
@@ -32,14 +32,22 @@ const OPENAI_MODEL_RE = /(^|[/.:])(gpt|chatgpt|codex)[-.]|(^|[/.:])o[134](?:[-.]
  * Selects the eval-first batching dialect for a model id:
  * - `claude`: Claude/GLM — direct imperatives; both are steered most reliably
  *   by explicit tagged directives (GLM prompting guidance routes to Claude's).
- * - `codex`: OpenAI reasoning families — terse bounded rules, no emphasis spam.
+ * - `gpt`: GPT models — terse composition-forward rules that direct detached
+ *   cells to notify on completion instead of being polled.
+ * - `codex`: Other OpenAI reasoning families — terse bounded rules, no emphasis spam.
  * - `kimi`: Kimi K-series — maximum-emphasis POSITIVE imperatives (uppercase/
  *   bold DO-framing); all-caps NEVER prohibitions stay out because they make
  *   K-series overthink instead of comply.
  * - `default`: everything else (and no model) — maximum-emphasis fallback.
  */
+/** True only for GPT model ids that receive the terse eval composition dialect. */
+export function isGptCodeModeModel(modelId: string | undefined): boolean {
+	return modelId !== undefined && /(^|[/.:])gpt[-.]/iu.test(modelId);
+}
+
 export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyle {
 	if (!modelId) return "default";
+	if (isGptCodeModeModel(modelId)) return "gpt";
 	if (CLAUDE_MODEL_RE.test(modelId) || GLM_MODEL_RE.test(modelId)) return "claude";
 	if (KIMI_MODEL_RE.test(modelId)) return "kimi";
 	if (OPENAI_MODEL_RE.test(modelId)) return "codex";
@@ -92,7 +100,11 @@ Work incrementally: imports in one call, define in the next, test, then use —
 - Enumerate every lookup the step needs, then run all independent ones simultaneously with \`parallel(thunks)\` inside the cell; keep calls sequential only when one result feeds the next.
 - Write real code around the calls: loop or comprehend over file sets with \`read()\`/stdlib, branch per case, and wrap risky calls in try/except so one failure degrades only its item — recover or retry inside the cell, keep the batch alive.
 - Post-process \`tool.<name>()\` results programmatically and return distilled facts, not raw dumps.
-</eval_first_batching>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
+</eval_first_batching>{{/if}}{{#if styleGpt}}<gpt_eval_dialect>
+GPT eval: compose multi-tool work inside one cell with \`tool.<name>(args)\` and \`parallel(thunks)\`; do not split a planned step into serial tool calls.
+- Long pure-compute cells detach on timeout and notify on completion. Do not poll or re-run them; use \`eval({ action: "peek"|"stop", cell_id })\` only to inspect or stop a detached cell.
+- Reduce tool results in the cell and return only decision-relevant facts.
+</gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
 - Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
 - Wrap failable calls in try/except inside the cell; a failed item degrades only itself. After two distinct failed strategies for the same fact, fall back to direct tool calls.
 - Reduce large results in-kernel to the facts the task needs before returning.{{/if}}{{#if styleKimi}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
@@ -112,13 +124,17 @@ Fields:
 - \`code\` — cell body, verbatim. Newlines/quotes JSON-encoded; no fences, no headers.
 - \`title\` (optional) — short transcript label (e.g. \`"imports"\`).
 - \`timeout\` (optional) — seconds. Raise only for heavy compute or long{{#if spawns}} non-agent{{/if}} tool calls.
+- \`on_timeout\` (optional) — \`"detach"\` keeps pure computation running in interactive sessions (the default); \`"error"\` interrupts for deadline-sensitive work and is the print/json default.
 - \`reset\` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a \`py\` reset never touches the JS VM.{{/ifAll}}
+- \`action\` (optional) — defaults to \`"run"\`. A detached cell returns its id: use \`eval({ action: "peek", cell_id })\` for buffered output/state or \`eval({ action: "stop", cell_id })\` to cancel it.
+
+A detached cell keeps its language kernel busy while it finishes. Do not re-run a detached cell: the same-language busy error names its cell id and output tail; another language can continue. Completion arrives as one notification with the final value/error and buffered output. Stopping a cell interrupts its kernel; the stop result states whether kernel state survived or the kernel was restarted and its variables lost.
 
 {{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(…)\` raises "cannot be called from a running event loop".{{/if}}
 {{#if js}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}
 {{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
 {{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
-On error, fix and re-run only the failing step — prior calls' state survives.
+On error, fix and re-run only the failing step. State usually survives a normal error, but a timeout or stop may have restarted the kernel — its message says which. Before rebuilding state, check a sentinel (a variable you defined earlier); only re-establish what is actually gone, since blind re-runs duplicate side effects.
 </instruction>
 
 <prelude>
@@ -135,9 +151,14 @@ write(path, content) → str
 env(key?=None, value?=None) → str | None | dict
     No args → full env dict; one → value of \`key\`; two → set \`key=value\`, return value.
 {{#if spawns}}output(*ids, format?="raw", offset?=None, limit?=None) → str | dict | list[dict]
-    Task/agent output by id. \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
+    Task/agent output by id. Reads immediately: running tasks return their status; \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
 {{/if}}tool.<name>(args) → unknown
     Invoke any session tool; \`args\` = its parameter object.
+tool_schema(name?) → dict
+    Parameter schema of a tool without calling it; omit \`name\` to list tool names.
+    Use it before calling a tool you have not called before — a failed call also
+    returns the expected parameters, so fix the args and retry in the next cell
+    instead of abandoning eval.
 completion(prompt, model?="default", system?=None, schema?=None) → str | dict
     Oneshot, stateless (no history/tools). \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → structured output, parsed object.
 {{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict
@@ -186,6 +207,7 @@ export function buildEvalPrompt(
 		spawnDefaultAgent,
 		styleClaude: style === "claude",
 		styleCodex: style === "codex",
+		styleGpt: style === "gpt",
 		styleKimi: style === "kimi",
 		styleDefault: style === "default",
 		hostLine: options.hostLine ?? "",
@@ -225,6 +247,7 @@ const BATCHING_GUIDELINES: Record<EvalEmphasisStyle, string> = {
 	claude:
 		"Prefer eval for any step needing more than one tool call: one cell that runs independent calls in parallel, handles per-call failures in code, and returns distilled facts.",
 	codex: "Route multi-call steps through eval: one cell per step, independent calls dispatched in parallel; fall back to direct tool calls when one call is sufficient or each result changes the next decision.",
+	gpt: "Use eval to compose tool work in one cell; long cells detach on timeout and notify on completion, so do not poll.",
 	kimi: "**EVAL IS YOUR SUPERPOWER — DEFAULT TO IT.** Execute EVERY multi-call step as ONE eval cell: run ALL independent calls simultaneously via parallel(thunks), handle failures per item in code, and return ONLY distilled facts.",
 };