pi-studio 0.8.4 → 0.9.1

package/index.ts

@@ -1,8 +1,9 @@
 import type { ExtensionAPI, ExtensionCommandContext, SessionEntry, Theme } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
 import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { homedir, tmpdir } from "node:os";
@@ -35,6 +36,7 @@ type StudioSourceKind = "file" | "last-response" | "blank";
 type TerminalActivityPhase = "idle" | "running" | "tool" | "responding";
 type StudioPromptMode = "response" | "run" | "effective";
 type StudioPromptTriggerKind = "run" | "steer";
+type StudioReplRuntime = "shell" | "python" | "ipython" | "julia" | "r" | "ghci" | "clojure";
 
 const STUDIO_CSS_URL = new URL("./client/studio.css", import.meta.url);
 const STUDIO_ANNOTATION_HELPERS_URL = new URL("./client/studio-annotation-helpers.js", import.meta.url);
@@ -111,6 +113,14 @@ interface StudioContextUsageSnapshot {
 	percent: number | null;
 }
 
+interface StudioReplSessionInfo {
+	sessionName: string;
+	target: string;
+	runtime: StudioReplRuntime | "unknown";
+	label: string;
+	source: "studio" | "pi-repl" | "tmux";
+}
+
 interface PreparedStudioPdfExport {
 	pdf: Buffer;
 	filename: string;
@@ -267,6 +277,41 @@ interface SendRunRequestMessage {
 	text: string;
 }
 
+interface ReplListRequestMessage {
+	type: "repl_list_request";
+}
+
+interface ReplCaptureRequestMessage {
+	type: "repl_capture_request";
+	sessionName?: string;
+}
+
+interface ReplStartRequestMessage {
+	type: "repl_start_request";
+	requestId: string;
+	runtime: StudioReplRuntime;
+	newSession?: boolean;
+}
+
+interface ReplStopRequestMessage {
+	type: "repl_stop_request";
+	requestId: string;
+	sessionName: string;
+}
+
+interface ReplSendRequestMessage {
+	type: "repl_send_request";
+	requestId: string;
+	sessionName: string;
+	text: string;
+}
+
+interface ReplInterruptRequestMessage {
+	type: "repl_interrupt_request";
+	requestId: string;
+	sessionName: string;
+}
+
 interface CompactRequestMessage {
 	type: "compact_request";
 	requestId: string;
@@ -331,6 +376,12 @@ type IncomingStudioMessage =
 	| CritiqueRequestMessage
 	| AnnotationRequestMessage
 	| SendRunRequestMessage
+	| ReplListRequestMessage
+	| ReplCaptureRequestMessage
+	| ReplStartRequestMessage
+	| ReplStopRequestMessage
+	| ReplSendRequestMessage
+	| ReplInterruptRequestMessage
 	| CompactRequestMessage
 	| SaveAsRequestMessage
 	| SaveOverRequestMessage
@@ -359,6 +410,30 @@ const STUDIO_TRACE_IMAGE_MAX_BASE64_CHARS = 2_500_000;
 const STUDIO_TRACE_SNAPSHOT_MAX_IMAGES = 12;
 const STUDIO_TRACE_SNAPSHOT_MAX_IMAGE_BASE64_CHARS = 6_000_000;
 const STUDIO_TRACE_IMAGE_SAFE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+const STUDIO_REPL_CAPTURE_LINES = 800;
+const STUDIO_REPL_SEND_MAX_CHARS = 200_000;
+const STUDIO_REPL_SEND_DEFAULT_TIMEOUT_MS = 20_000;
+const STUDIO_REPL_SEND_MAX_TIMEOUT_MS = 120_000;
+const STUDIO_REPL_CONTROL_ROOT = join(tmpdir(), "pi-studio-repl");
+const STUDIO_REPL_RUNTIME_LABELS: Record<StudioReplRuntime, string> = {
+	shell: "Shell",
+	python: "Python",
+	ipython: "IPython",
+	julia: "Julia",
+	r: "R",
+	ghci: "GHCi",
+	clojure: "Clojure",
+};
+const STUDIO_REPL_SEND_TOOL_PARAMS = Type.Object({
+	code: Type.String({ description: "Code to execute in the active or selected Studio REPL session." }),
+	sessionName: Type.Optional(Type.String({ description: "Exact Studio/pi-repl tmux session name. If omitted, Studio uses the active REPL session, or the first session matching target." })),
+	target: Type.Optional(Type.String({ description: "Optional runtime target: shell, python, ipython, julia, r, ghci, or clojure. Used when sessionName is omitted." })),
+	timeoutMs: Type.Optional(Type.Number({ description: "Maximum time to wait for completion when Studio can detect it (default 20000, max 120000).", minimum: 1000, maximum: STUDIO_REPL_SEND_MAX_TIMEOUT_MS })),
+});
+const STUDIO_REPL_STATUS_TOOL_PARAMS = Type.Object({
+	sessionName: Type.Optional(Type.String({ description: "Exact Studio/pi-repl tmux session name to inspect." })),
+	target: Type.Optional(Type.String({ description: "Optional runtime target: shell, python, ipython, julia, r, ghci, or clojure. If omitted, report all Studio-visible REPL sessions." })),
+});
 const MAX_STUDIO_TRACE_SNAPSHOTS = RESPONSE_HISTORY_LIMIT;
 const TRANSIENT_STUDIO_DOCUMENT_TTL_MS = 30 * 60 * 1000;
 const MAX_TRANSIENT_STUDIO_DOCUMENTS = 16;
@@ -374,6 +449,7 @@ const STUDIO_PERSISTENT_STATE_PATH = join(STUDIO_PERSISTENT_STATE_DIR, "local-st
 let studioPersistentStateCache: StudioPersistentState | null = null;
 let studioPersistentStateQueue: Promise<void> = Promise.resolve();
 let transientStudioDocuments: Map<string, { document: InitialStudioDocument; createdAt: number }> = new Map();
+const studioReplControlSubmissionLabels = new Map<string, string>();
 
 function createEmptyStudioPersistentState(): StudioPersistentState {
 	return {
@@ -6411,6 +6487,54 @@ function parseIncomingMessage(data: RawData): IncomingStudioMessage | null {
 		};
 	}
 
+	if (msg.type === "repl_list_request") {
+		return { type: "repl_list_request" };
+	}
+
+	if (msg.type === "repl_capture_request") {
+		return {
+			type: "repl_capture_request",
+			sessionName: typeof msg.sessionName === "string" ? msg.sessionName : undefined,
+		};
+	}
+
+	if (msg.type === "repl_start_request" && typeof msg.requestId === "string") {
+		const runtime = normalizeStudioReplRuntime(msg.runtime);
+		if (runtime) {
+			return {
+				type: "repl_start_request",
+				requestId: msg.requestId,
+				runtime,
+				newSession: Boolean(msg.newSession),
+			};
+		}
+	}
+
+	if (msg.type === "repl_stop_request" && typeof msg.requestId === "string" && typeof msg.sessionName === "string") {
+		return {
+			type: "repl_stop_request",
+			requestId: msg.requestId,
+			sessionName: msg.sessionName,
+		};
+	}
+
+	if (msg.type === "repl_send_request" && typeof msg.requestId === "string" && typeof msg.sessionName === "string" && typeof msg.text === "string") {
+		return {
+			type: "repl_send_request",
+			requestId: msg.requestId,
+			sessionName: msg.sessionName,
+			text: msg.text,
+		};
+	}
+
+	if (msg.type === "repl_interrupt_request" && typeof msg.requestId === "string" && typeof msg.sessionName === "string") {
+		return {
+			type: "repl_interrupt_request",
+			requestId: msg.requestId,
+			sessionName: msg.sessionName,
+		};
+	}
+
 	if (
 		msg.type === "compact_request" &&
 		typeof msg.requestId === "string" &&
@@ -6922,7 +7046,7 @@ function summarizeStudioTraceToolArgs(toolName: string, args: unknown): string |
 	if (normalizedTool === "read" || normalizedTool === "write" || normalizedTool === "edit") {
 		return trimSummary(typeof payload.path === "string" ? payload.path : "");
 	}
-	if (normalizedTool === "repl_send") {
+	if (normalizedTool === "repl_send" || normalizedTool === "studio_repl_send") {
 		return trimSummary(typeof payload.code === "string" ? payload.code : "");
 	}
 	try {
@@ -6932,6 +7056,501 @@ function summarizeStudioTraceToolArgs(toolName: string, args: unknown): string |
 	}
 }
 
+function isStudioReplRuntime(value: unknown): value is StudioReplRuntime {
+	return value === "shell"
+		|| value === "python"
+		|| value === "ipython"
+		|| value === "julia"
+		|| value === "r"
+		|| value === "ghci"
+		|| value === "clojure";
+}
+
+function normalizeStudioReplRuntime(value: unknown): StudioReplRuntime | null {
+	const normalized = String(value || "").trim().toLowerCase();
+	if (normalized === "r") return "r";
+	return isStudioReplRuntime(normalized) ? normalized : null;
+}
+
+function getStudioReplRuntimeCommand(runtime: StudioReplRuntime): string {
+	if (runtime === "shell") return String(process.env.SHELL || "bash").trim() || "bash";
+	if (runtime === "python") return "python3";
+	if (runtime === "ipython") return "ipython";
+	if (runtime === "julia") return "julia";
+	if (runtime === "r") return "R";
+	if (runtime === "ghci") return "ghci";
+	return "clojure";
+}
+
+function getStudioReplSessionName(runtime: StudioReplRuntime): string {
+	return `pi-studio-repl-${runtime}`;
+}
+
+function getNewStudioReplSessionName(runtime: StudioReplRuntime): string {
+	const suffix = `${Date.now().toString(36)}-${randomUUID().slice(0, 6)}`;
+	return `pi-studio-repl-${runtime}-${suffix}`;
+}
+
+function getStudioReplPaneTarget(sessionName: string): string {
+	return `${sessionName}:0.0`;
+}
+
+function inferStudioReplSessionRuntime(sessionName: string): { runtime: StudioReplRuntime | "unknown"; source: StudioReplSessionInfo["source"] } {
+	const studioMatch = sessionName.match(/^pi-studio-repl-([a-z0-9-]+)$/i);
+	if (studioMatch) {
+		const raw = (studioMatch[1] || "").toLowerCase();
+		const runtime = (["clojure", "python", "ipython", "julia", "shell", "ghci", "r"] as StudioReplRuntime[])
+			.find((candidate) => raw === candidate || raw.startsWith(`${candidate}-`));
+		return { runtime: runtime ?? "unknown", source: "studio" };
+	}
+	const piReplMatch = sessionName.match(/^pi-repl-([a-z0-9-]+)$/i);
+	if (piReplMatch) {
+		const raw = piReplMatch[1]?.toLowerCase() || "";
+		const runtime = raw === "python" ? "python" : normalizeStudioReplRuntime(raw);
+		return { runtime: runtime ?? "unknown", source: "pi-repl" };
+	}
+	return { runtime: "unknown", source: "tmux" };
+}
+
+function shouldShowStudioReplTmuxSession(sessionName: string): boolean {
+	return /^pi-studio-repl-/i.test(sessionName) || /^pi-repl-/i.test(sessionName);
+}
+
+function formatStudioReplSessionLabel(sessionName: string, runtime: StudioReplRuntime | "unknown", source: StudioReplSessionInfo["source"]): string {
+	const runtimeLabel = runtime === "unknown" ? "REPL" : STUDIO_REPL_RUNTIME_LABELS[runtime];
+	if (source === "pi-repl") return `${runtimeLabel} (${sessionName})`;
+	if (source === "studio") return `${runtimeLabel} (${sessionName})`;
+	return sessionName;
+}
+
+function isTmuxAvailable(): boolean {
+	const result = spawnSync("tmux", ["-V"], { encoding: "utf8", timeout: 3_000 });
+	return result.status === 0;
+}
+
+function runStudioTmux(args: string[], options?: { cwd?: string; input?: string; timeout?: number }): { ok: true; stdout: string; stderr: string } | { ok: false; message: string; stdout: string; stderr: string } {
+	const result = spawnSync("tmux", args, {
+		cwd: options?.cwd,
+		input: options?.input,
+		encoding: "utf8",
+		timeout: options?.timeout ?? 5_000,
+		maxBuffer: 10 * 1024 * 1024,
+	});
+	const stdout = typeof result.stdout === "string" ? result.stdout : "";
+	const stderr = typeof result.stderr === "string" ? result.stderr : "";
+	if (result.error) {
+		const message = result.error.message || String(result.error);
+		return { ok: false, message, stdout, stderr };
+	}
+	if (result.status !== 0) {
+		return { ok: false, message: (stderr || stdout || `tmux exited with code ${result.status}`).trim(), stdout, stderr };
+	}
+	return { ok: true, stdout, stderr };
+}
+
+function listStudioReplSessions(): { tmuxAvailable: boolean; sessions: StudioReplSessionInfo[]; error?: string } {
+	if (!isTmuxAvailable()) return { tmuxAvailable: false, sessions: [], error: "tmux is not available." };
+	const result = runStudioTmux(["list-sessions", "-F", "#{session_name}"], { timeout: 3_000 });
+	if (!result.ok) {
+		const message = result.message.toLowerCase().includes("no server running") ? "No tmux sessions are running." : result.message;
+		return { tmuxAvailable: true, sessions: [], error: message };
+	}
+	const sessions = result.stdout
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter(Boolean)
+		.filter(shouldShowStudioReplTmuxSession)
+		.map((sessionName) => {
+			const inferred = inferStudioReplSessionRuntime(sessionName);
+			return {
+				sessionName,
+				target: getStudioReplPaneTarget(sessionName),
+				runtime: inferred.runtime,
+				label: formatStudioReplSessionLabel(sessionName, inferred.runtime, inferred.source),
+				source: inferred.source,
+			};
+		});
+	return { tmuxAvailable: true, sessions };
+}
+
+function getStudioReplPromptPrefix(line: string): string {
+	const source = String(line || "");
+	const match = source.match(/^(\s*(?:(?:In \[\d+\]:)|(?:\.\.\.)|(?:>>>)|(?:julia>)|(?:ghci>)|(?:Prelude>)|(?:\*?[A-Za-z0-9_.:]+>)|(?:[^\s>]+=>)|(?:>)|(?:\+))\s*)/);
+	return match ? (match[1] || "") : "";
+}
+
+function sanitizeStudioReplTranscript(transcript: string): string {
+	let value = String(transcript || "");
+	for (const [sourceFile, label] of studioReplControlSubmissionLabels) {
+		if (!value.includes(sourceFile)) continue;
+		const escaped = sourceFile.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const linePattern = new RegExp(`^.*${escaped}.*$`, "gm");
+		value = value.replace(linePattern, (line) => `${getStudioReplPromptPrefix(line)}${label}`.trimEnd());
+	}
+	return value.replace(/[\t ]+$/gm, "").trimEnd();
+}
+
+function captureStudioReplSession(sessionName: string): { ok: true; transcript: string; session: StudioReplSessionInfo } | { ok: false; message: string } {
+	if (!/^[-_.A-Za-z0-9]+$/.test(sessionName)) return { ok: false, message: "Invalid REPL session name." };
+	const inferred = inferStudioReplSessionRuntime(sessionName);
+	const session: StudioReplSessionInfo = {
+		sessionName,
+		target: getStudioReplPaneTarget(sessionName),
+		runtime: inferred.runtime,
+		label: formatStudioReplSessionLabel(sessionName, inferred.runtime, inferred.source),
+		source: inferred.source,
+	};
+	const result = runStudioTmux(["capture-pane", "-J", "-p", "-t", session.target, "-S", `-${STUDIO_REPL_CAPTURE_LINES}`], { timeout: 3_000 });
+	if (!result.ok) return { ok: false, message: result.message };
+	return { ok: true, transcript: sanitizeStudioReplTranscript(result.stdout), session };
+}
+
+function startStudioReplSession(runtime: StudioReplRuntime, cwd: string, options?: { newSession?: boolean }): { ok: true; session: StudioReplSessionInfo; message: string } | { ok: false; message: string } {
+	if (!isTmuxAvailable()) return { ok: false, message: "tmux is not available. Install tmux to use Studio REPL sessions." };
+	const sessionName = options?.newSession ? getNewStudioReplSessionName(runtime) : getStudioReplSessionName(runtime);
+	const existing = runStudioTmux(["has-session", "-t", sessionName], { timeout: 3_000 });
+	if (existing.ok) {
+		const inferred = inferStudioReplSessionRuntime(sessionName);
+		return {
+			ok: true,
+			session: {
+				sessionName,
+				target: getStudioReplPaneTarget(sessionName),
+				runtime: inferred.runtime,
+				label: formatStudioReplSessionLabel(sessionName, inferred.runtime, inferred.source),
+				source: inferred.source,
+			},
+			message: `${STUDIO_REPL_RUNTIME_LABELS[runtime]} REPL is already running.`,
+		};
+	}
+	const command = getStudioReplRuntimeCommand(runtime);
+	const result = runStudioTmux(["new-session", "-d", "-s", sessionName, "-c", cwd || process.cwd(), command], { timeout: 5_000 });
+	if (!result.ok) return { ok: false, message: result.message || `Failed to start ${STUDIO_REPL_RUNTIME_LABELS[runtime]} REPL.` };
+	return {
+		ok: true,
+		session: {
+			sessionName,
+			target: getStudioReplPaneTarget(sessionName),
+			runtime,
+			label: formatStudioReplSessionLabel(sessionName, runtime, "studio"),
+			source: "studio",
+		},
+		message: `Started ${options?.newSession ? "new " : ""}${STUDIO_REPL_RUNTIME_LABELS[runtime]} REPL.`,
+	};
+}
+
+function stopStudioReplSession(sessionName: string): { ok: true; message: string } | { ok: false; message: string } {
+	if (!/^[-_.A-Za-z0-9]+$/.test(sessionName)) return { ok: false, message: "Invalid REPL session name." };
+	const inferred = inferStudioReplSessionRuntime(sessionName);
+	if (inferred.source !== "studio") {
+		return { ok: false, message: "Studio can only stop Studio-owned REPL sessions. Use tmux or pi-repl to stop external sessions." };
+	}
+	const result = runStudioTmux(["kill-session", "-t", sessionName], { timeout: 5_000 });
+	if (!result.ok) return { ok: false, message: result.message || "Failed to stop REPL session." };
+	return { ok: true, message: `Stopped ${sessionName}.` };
+}
+
+type StudioReplControlFiles = {
+	dir: string;
+	sourceFile: string;
+	doneFile: string;
+};
+
+type StudioReplPreparedSubmission = {
+	runtime: StudioReplRuntime | "unknown";
+	usedControlFile: boolean;
+	submissionText: string;
+	controlFiles?: StudioReplControlFiles;
+};
+
+type StudioReplSendSuccess = {
+	ok: true;
+	message: string;
+	runtime: StudioReplRuntime | "unknown";
+	usedControlFile: boolean;
+	submissionText: string;
+	controlFiles?: StudioReplControlFiles;
+};
+
+type StudioReplSendFailure = { ok: false; message: string };
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+
+function clampStudioReplSendTimeout(timeoutMs: number | undefined): number {
+	if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) return STUDIO_REPL_SEND_DEFAULT_TIMEOUT_MS;
+	return Math.max(1_000, Math.min(STUDIO_REPL_SEND_MAX_TIMEOUT_MS, Math.round(timeoutMs)));
+}
+
+function shellQuote(value: string): string {
+	return `'${String(value || "").replace(/'/g, `'"'"'`)}'`;
+}
+
+function getStudioReplControlFiles(sessionName: string, runtime: StudioReplRuntime | "unknown"): StudioReplControlFiles {
+	const safeSession = sessionName.replace(/[^-_.A-Za-z0-9]+/g, "_");
+	const safeRuntime = String(runtime || "repl").replace(/[^-_.A-Za-z0-9]+/g, "_");
+	const dir = join(STUDIO_REPL_CONTROL_ROOT, safeSession, randomUUID().replace(/-/g, ""));
+	const extension = runtime === "julia"
+		? "jl"
+		: runtime === "r"
+			? "R"
+			: runtime === "ghci"
+				? "ghci"
+				: runtime === "clojure"
+					? "clj"
+					: "py";
+	return {
+		dir,
+		sourceFile: join(dir, `studio-repl-${safeRuntime}.${extension}`),
+		doneFile: join(dir, "done.flag"),
+	};
+}
+
+function buildStudioPythonControlSource(runtime: "python" | "ipython", code: string, doneFile: string): string {
+	if (runtime === "ipython") {
+		return [
+			"from pathlib import Path as __pi_studio_path",
+			"import traceback as __pi_studio_traceback",
+			"try:",
+			"    __pi_studio_ip = get_ipython()",
+			"    if __pi_studio_ip is None:",
+			"        raise RuntimeError('Expected IPython session, but get_ipython() returned None.')",
+			`    __pi_studio_result = __pi_studio_ip.run_cell(${JSON.stringify(code)}, store_history=False)`,
+			"    if getattr(__pi_studio_result, 'error_in_exec', None) is None and getattr(__pi_studio_result, 'result', None) is not None:",
+			"        print(repr(__pi_studio_result.result))",
+			"except Exception:",
+			"    __pi_studio_traceback.print_exc()",
+			"finally:",
+			`    __pi_studio_path(${JSON.stringify(doneFile)}).write_text('done\\n', encoding='utf-8')`,
+		].join("\n");
+	}
+
+	return [
+		"from pathlib import Path as __pi_studio_path",
+		"import traceback as __pi_studio_traceback",
+		`__pi_studio_code = ${JSON.stringify(code)}`,
+		"try:",
+		"    try:",
+		"        __pi_studio_expr = compile(__pi_studio_code, '<pi-studio-repl>', 'eval')",
+		"    except SyntaxError:",
+		"        exec(compile(__pi_studio_code, '<pi-studio-repl>', 'exec'), globals())",
+		"    else:",
+		"        __pi_studio_value = eval(__pi_studio_expr, globals())",
+		"        if __pi_studio_value is not None:",
+		"            print(repr(__pi_studio_value))",
+		"except Exception:",
+		"    __pi_studio_traceback.print_exc()",
+		"finally:",
+		`    __pi_studio_path(${JSON.stringify(doneFile)}).write_text('done\\n', encoding='utf-8')`,
+	].join("\n");
+}
+
+function buildStudioJuliaControlSource(code: string, doneFile: string): string {
+	return [
+		"try",
+		`    local __pi_studio_result = Base.include_string(Main, ${JSON.stringify(code)}, "pi-studio-repl")`,
+		"    if !isnothing(__pi_studio_result)",
+		"        println(repr(__pi_studio_result))",
+		"    end",
+		"catch e",
+		"    Base.display_error(stderr, e, catch_backtrace())",
+		"finally",
+		`    write(${JSON.stringify(doneFile)}, "done\\n")`,
+		"end",
+	].join("\n");
+}
+
+function buildStudioRControlSource(code: string, doneFile: string): string {
+	return [
+		"local({",
+		`  .__pi_studio_done_file <- ${JSON.stringify(doneFile)}`,
+		`  .__pi_studio_code <- ${JSON.stringify(code)}`,
+		"  tryCatch({",
+		"    .__pi_studio_exprs <- parse(text = .__pi_studio_code, keep.source = FALSE)",
+		"    .__pi_studio_value <- NULL",
+		"    .__pi_studio_visible <- FALSE",
+		"    for (.__pi_studio_expr in .__pi_studio_exprs) {",
+		"      .__pi_studio_result <- withVisible(eval(.__pi_studio_expr, envir = .GlobalEnv))",
+		"      .__pi_studio_value <- .__pi_studio_result$value",
+		"      .__pi_studio_visible <- isTRUE(.__pi_studio_result$visible)",
+		"    }",
+		"    if (.__pi_studio_visible) print(.__pi_studio_value)",
+		"  }, error = function(e) {",
+		"    .__pi_studio_call <- conditionCall(e)",
+		"    if (is.null(.__pi_studio_call)) {",
+		"      message(\"Error: \", conditionMessage(e))",
+		"    } else {",
+		"      message(\"Error in \", paste(deparse(.__pi_studio_call), collapse = \" \"), \": \", conditionMessage(e))",
+		"    }",
+		"  }, finally = {",
+		"    writeLines(\"done\", .__pi_studio_done_file)",
+		"  })",
+		"})",
+	].join("\n");
+}
+
+function buildStudioClojureControlSource(code: string, doneFile: string): string {
+	return [
+		"(let [code " + JSON.stringify(code) + "]",
+		"  (try",
+		"    (let [rdr (clojure.lang.LineNumberingPushbackReader. (java.io.StringReader. code))]",
+		"      (loop [last-val nil has-val false]",
+		"        (let [form (read rdr false :pi-studio/eof)]",
+		"          (if (= form :pi-studio/eof)",
+		"            (when (and has-val (some? last-val)) (prn last-val))",
+		"            (recur (eval form) true)))))",
+		"    (catch Throwable t",
+		"      (#'clojure.main/repl-caught t))",
+		"    (finally",
+		`      (spit ${JSON.stringify(doneFile)} "done\\n"))))`,
+	].join("\n");
+}
+
+function buildStudioReplControlSource(runtime: StudioReplRuntime, code: string, doneFile: string): string | null {
+	if (runtime === "python" || runtime === "ipython") return buildStudioPythonControlSource(runtime, code, doneFile);
+	if (runtime === "julia") return buildStudioJuliaControlSource(code, doneFile);
+	if (runtime === "r") return buildStudioRControlSource(code, doneFile);
+	if (runtime === "ghci") return `${code.replace(/\r/g, "").trimEnd()}\n:! touch ${shellQuote(doneFile)}\n`;
+	if (runtime === "clojure") return buildStudioClojureControlSource(code, doneFile);
+	return null;
+}
+
+function buildStudioReplSubmissionLine(runtime: StudioReplRuntime, sourceFile: string): string {
+	const quotedPath = JSON.stringify(sourceFile);
+	if (runtime === "julia") return `include(${quotedPath})`;
+	if (runtime === "r") return `source(${quotedPath}, local=.GlobalEnv)`;
+	if (runtime === "ghci") return `:script ${quotedPath}`;
+	if (runtime === "clojure") return `(do (load-file ${quotedPath}) :pi-studio/silent)`;
+	return `exec(open(${quotedPath}, encoding="utf-8").read(), globals())`;
+}
+
+function buildStudioReplPreviewComment(runtime: StudioReplRuntime, code: string): string | undefined {
+	const normalized = code.replace(/\r/g, "").trimEnd();
+	const lineCount = normalized ? normalized.split("\n").length : 0;
+	if (lineCount <= 1) return undefined;
+	const prefix = runtime === "ghci" ? "--" : runtime === "clojure" ? ";;" : "#";
+	return `${prefix} Studio sent ${lineCount}-line snippet`;
+}
+
+function buildStudioReplDisplayLabel(runtime: StudioReplRuntime, code: string): string {
+	const normalized = code.replace(/\r/g, "").trim();
+	const singleLine = normalized && !normalized.includes("\n") ? normalized.replace(/\s+/g, " ") : "";
+	if (singleLine && singleLine.length <= 140) return singleLine;
+	return buildStudioReplPreviewComment(runtime, code) || "# Studio sent code";
+}
+
+function rememberStudioReplControlSubmission(sourceFile: string, label: string): void {
+	studioReplControlSubmissionLabels.set(sourceFile, label);
+	while (studioReplControlSubmissionLabels.size > 300) {
+		const oldest = studioReplControlSubmissionLabels.keys().next().value;
+		if (!oldest) break;
+		studioReplControlSubmissionLabels.delete(oldest);
+	}
+}
+
+function prepareStudioReplSubmission(sessionName: string, source: string): StudioReplPreparedSubmission {
+	const normalizedSource = String(source || "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	const runtime = inferStudioReplSessionRuntime(sessionName).runtime;
+	if (runtime !== "unknown" && runtime !== "shell") {
+		const controlFiles = getStudioReplControlFiles(sessionName, runtime);
+		const controlSource = buildStudioReplControlSource(runtime, normalizedSource, controlFiles.doneFile);
+		if (controlSource) {
+			mkdirSync(controlFiles.dir, { recursive: true });
+			try {
+				unlinkSync(controlFiles.doneFile);
+			} catch {
+				// Ignore stale done file cleanup failures.
+			}
+			writeFileSync(controlFiles.sourceFile, controlSource, "utf-8");
+			const submissionLine = buildStudioReplSubmissionLine(runtime, controlFiles.sourceFile);
+			rememberStudioReplControlSubmission(controlFiles.sourceFile, buildStudioReplDisplayLabel(runtime, normalizedSource));
+			return {
+				runtime,
+				usedControlFile: true,
+				controlFiles,
+				submissionText: submissionLine,
+			};
+		}
+	}
+
+	return {
+		runtime,
+		usedControlFile: false,
+		submissionText: normalizedSource.replace(/\n+$/, ""),
+	};
+}
+
+function pasteTextToStudioReplPane(sessionName: string, text: string): { ok: true } | { ok: false; message: string } {
+	const bufferName = `pi-studio-repl-${randomUUID().replace(/-/g, "")}`;
+	const target = getStudioReplPaneTarget(sessionName);
+	const loadResult = runStudioTmux(["load-buffer", "-b", bufferName, "-"], { input: text, timeout: 5_000 });
+	if (!loadResult.ok) return { ok: false, message: loadResult.message || "Failed to load text into tmux buffer." };
+	try {
+		const pasteResult = runStudioTmux(["paste-buffer", "-d", "-b", bufferName, "-t", target], { timeout: 5_000 });
+		if (!pasteResult.ok) return { ok: false, message: pasteResult.message || "Failed to paste text into REPL session." };
+		const enterResult = runStudioTmux(["send-keys", "-t", target, "C-m"], { timeout: 5_000 });
+		if (!enterResult.ok) return { ok: false, message: enterResult.message || "Failed to send Enter to REPL session." };
+		return { ok: true };
+	} finally {
+		runStudioTmux(["delete-buffer", "-b", bufferName], { timeout: 2_000 });
+	}
+}
+
+function sendTextToStudioReplSession(sessionName: string, text: string): StudioReplSendSuccess | StudioReplSendFailure {
+	if (!/^[-_.A-Za-z0-9]+$/.test(sessionName)) return { ok: false, message: "Invalid REPL session name." };
+	const source = String(text || "");
+	if (!source.trim()) return { ok: false, message: "Editor text is empty." };
+	if (source.length > STUDIO_REPL_SEND_MAX_CHARS) {
+		return { ok: false, message: `REPL input is too large (${source.length} chars; max ${STUDIO_REPL_SEND_MAX_CHARS}).` };
+	}
+	const prepared = prepareStudioReplSubmission(sessionName, source);
+	const pasted = pasteTextToStudioReplPane(sessionName, prepared.submissionText);
+	if (!pasted.ok) return { ok: false, message: pasted.message };
+	return {
+		ok: true,
+		message: "Sent to REPL.",
+		runtime: prepared.runtime,
+		usedControlFile: prepared.usedControlFile,
+		submissionText: prepared.submissionText,
+		controlFiles: prepared.controlFiles,
+	};
+}
+
+function extractStudioReplTranscriptDelta(before: string, after: string): string {
+	const previous = String(before || "");
+	const current = String(after || "");
+	if (!current) return "";
+	if (!previous) return current.trim();
+	const directIndex = current.indexOf(previous);
+	if (directIndex >= 0) return current.slice(directIndex + previous.length).trim();
+	const previousLines = previous.split("\n");
+	for (let count = Math.min(previousLines.length, 40); count >= 1; count -= 1) {
+		const suffix = previousLines.slice(previousLines.length - count).join("\n");
+		if (!suffix.trim()) continue;
+		const suffixIndex = current.indexOf(suffix);
+		if (suffixIndex >= 0) return current.slice(suffixIndex + suffix.length).trim();
+	}
+	return current.trim();
+}
+
+async function waitForStudioReplDoneFile(doneFile: string | undefined, timeoutMs: number): Promise<boolean> {
+	if (!doneFile) return false;
+	const deadline = Date.now() + clampStudioReplSendTimeout(timeoutMs);
+	while (Date.now() < deadline) {
+		if (existsSync(doneFile)) return true;
+		await sleep(100);
+	}
+	return existsSync(doneFile);
+}
+
+function interruptStudioReplSession(sessionName: string): { ok: true; message: string } | { ok: false; message: string } {
+	if (!/^[-_.A-Za-z0-9]+$/.test(sessionName)) return { ok: false, message: "Invalid REPL session name." };
+	const result = runStudioTmux(["send-keys", "-t", getStudioReplPaneTarget(sessionName), "C-c"], { timeout: 5_000 });
+	if (!result.ok) return { ok: false, message: result.message || "Failed to interrupt REPL session." };
+	return { ok: true, message: `Interrupted ${sessionName}.` };
+}
+
 function isAllowedOrigin(_origin: string | undefined, _port: number): boolean {
 	// For local-only studio, token auth is the primary guard. In practice,
 	// browser origin headers can vary (or be omitted) across wrappers/browsers,
@@ -7422,6 +8041,11 @@ ${cssVarsBlock}
             <div class="source-actions-row">
               <button id="sendRunBtn" type="button" title="Run editor text. While a direct run is active, this button becomes Stop. Cmd/Ctrl+Enter queues steering from the current editor text. Stop the active request with Esc.">Run editor text</button>
               <button id="queueSteerBtn" type="button" title="Queue steering is available while Run editor text is active." disabled>Queue steering</button>
+              <button id="sendReplBtn" type="button" hidden title="Send the current selection, or the full editor text, to the active REPL session shown in the right pane.">Send to REPL</button>
+              <select id="replSendModeSelect" hidden aria-label="REPL send mode" title="Choose how Send to REPL interprets the editor text.">
+                <option value="raw" selected>Send mode: Raw</option>
+                <option value="literate">Send mode: Literate</option>
+              </select>
               <button id="copyDraftBtn" type="button" title="Copy the current editor text to the clipboard.">Copy text</button>
               <button id="openCompanionBtn" type="button" title="Open a detached copy of the current editor text in a new editor-only Studio tab.">Open new editor</button>
               <button id="sendEditorBtn" type="button">Send to pi editor</button>
@@ -7564,6 +8188,7 @@ ${cssVarsBlock}
             <option value="preview" selected>Response (Preview)</option>
             <option value="editor-preview">Editor (Preview)</option>
             <option value="trace">Working</option>
+            <option value="repl">REPL</option>
           </select>
         </div>
         <div class="section-header-actions">
@@ -7701,9 +8326,168 @@ export default function (pi: ExtensionAPI) {
 		contextWindow: null,
 		percent: null,
 	};
+	let studioReplActiveSessionName: string | null = null;
 	let compactInProgress = false;
 	let compactRequestId: string | null = null;
 
+	const selectStudioReplSessionForTool = (params: { sessionName?: string; target?: string }): { session: StudioReplSessionInfo | null; error?: string; sessions: StudioReplSessionInfo[] } => {
+		const state = listStudioReplSessions();
+		const sessions = state.sessions;
+		if (!state.tmuxAvailable) return { session: null, error: "tmux is not available.", sessions };
+		if (typeof params.sessionName === "string" && params.sessionName.trim()) {
+			const requested = params.sessionName.trim();
+			const session = sessions.find((candidate) => candidate.sessionName === requested) ?? null;
+			return session
+				? { session, sessions }
+				: { session: null, error: `No Studio-visible REPL session named ${requested}.`, sessions };
+		}
+		const target = normalizeStudioReplRuntime(params.target);
+		if (target) {
+			const active = studioReplActiveSessionName
+				? sessions.find((candidate) => candidate.sessionName === studioReplActiveSessionName && candidate.runtime === target)
+				: null;
+			const session = active ?? sessions.find((candidate) => candidate.runtime === target) ?? null;
+			return session
+				? { session, sessions }
+				: { session: null, error: `No running Studio-visible ${STUDIO_REPL_RUNTIME_LABELS[target]} REPL session.`, sessions };
+		}
+		if (studioReplActiveSessionName) {
+			const active = sessions.find((candidate) => candidate.sessionName === studioReplActiveSessionName);
+			if (active) return { session: active, sessions };
+		}
+		return sessions[0]
+			? { session: sessions[0], sessions }
+			: { session: null, error: "No Studio-visible REPL sessions are running. Open Studio REPL view or start a session first.", sessions };
+	};
+
+	const broadcastStudioReplToolSend = (payload: Record<string, unknown>) => {
+		if (!serverState) return;
+		const serialized = JSON.stringify({ type: "repl_tool_send", ...payload });
+		for (const client of serverState.clients) {
+			if (client.readyState !== WebSocket.OPEN) continue;
+			try {
+				client.send(serialized);
+			} catch {
+				// Ignore transport errors; close handler will clean up.
+			}
+		}
+	};
+
+	pi.registerTool({
+		name: "studio_repl_status",
+		label: "Studio REPL status",
+		description: "Inspect Studio-visible tmux REPL sessions and the active Studio REPL session.",
+		promptSnippet: "Inspect the active Studio REPL session and other Studio-visible REPL sessions.",
+		promptGuidelines: [
+			"Use studio_repl_status before claiming whether a Studio REPL session is active if you are unsure.",
+			"Use studio_repl_send, not raw tmux shell commands, when the user asks you to run code in the active Studio REPL.",
+		],
+		parameters: STUDIO_REPL_STATUS_TOOL_PARAMS,
+		async execute(_toolCallId, params) {
+			const selected = selectStudioReplSessionForTool({ sessionName: params.sessionName, target: params.target });
+			const lines = [
+				`Active Studio REPL: ${studioReplActiveSessionName || "none"}`,
+				`tmux sessions visible to Studio: ${selected.sessions.length}`,
+			];
+			if (selected.error) lines.push(`Selection: ${selected.error}`);
+			if (selected.session) {
+				lines.push(`Selected: ${selected.session.sessionName} (${selected.session.runtime}, ${selected.session.source})`);
+			}
+			for (const session of selected.sessions) {
+				lines.push(`- ${session.sessionName} | runtime=${session.runtime} | source=${session.source} | target=${session.target}`);
+			}
+			return {
+				content: [{ type: "text", text: lines.join("\n") }],
+				details: {
+					activeSessionName: studioReplActiveSessionName,
+					selectedSession: selected.session,
+					sessions: selected.sessions,
+				} as Record<string, unknown>,
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "studio_repl_send",
+		label: "Send to Studio REPL",
+		description: "Execute code in the active or selected Studio tmux-backed REPL session using Studio's safe runtime-specific submission protocol.",
+		promptSnippet: "Execute code in the active Studio REPL session safely, including multiline Python/R/Julia/GHCi/Clojure snippets.",
+		promptGuidelines: [
+			"Use studio_repl_send when the user asks to run code in the active Studio REPL.",
+			"Do not improvise tmux paste-buffer commands for Studio REPL code; studio_repl_send handles multiline quoting and runtime-specific submission.",
+			"If several REPL sessions of the same runtime are running, use studio_repl_status first or pass the exact sessionName when known.",
+		],
+		parameters: STUDIO_REPL_SEND_TOOL_PARAMS,
+		executionMode: "sequential",
+		async execute(toolCallId, params) {
+			const selected = selectStudioReplSessionForTool({ sessionName: params.sessionName, target: params.target });
+			if (!selected.session) {
+				return {
+					content: [{ type: "text", text: selected.error || "No Studio REPL session selected." }],
+					details: { ok: false, error: selected.error || "No Studio REPL session selected.", sessions: selected.sessions } as Record<string, unknown>,
+				};
+			}
+
+			const before = captureStudioReplSession(selected.session.sessionName);
+			const beforeTranscript = before.ok ? before.transcript : "";
+			const sent = sendTextToStudioReplSession(selected.session.sessionName, params.code);
+			if (!sent.ok) {
+				return {
+					content: [{ type: "text", text: sent.message }],
+					details: { ok: false, error: sent.message, session: selected.session, sessions: selected.sessions } as Record<string, unknown>,
+				};
+			}
+			studioReplActiveSessionName = selected.session.sessionName;
+
+			const timeoutMs = clampStudioReplSendTimeout(params.timeoutMs);
+			let completed = false;
+			if (sent.controlFiles?.doneFile) {
+				completed = await waitForStudioReplDoneFile(sent.controlFiles.doneFile, timeoutMs);
+			} else {
+				await sleep(Math.min(750, timeoutMs));
+			}
+			const after = captureStudioReplSession(selected.session.sessionName);
+			const afterTranscript = after.ok ? after.transcript : "";
+			const output = extractStudioReplTranscriptDelta(beforeTranscript, afterTranscript);
+			const statusLine = sent.controlFiles?.doneFile
+				? (completed ? "Completed." : `Timed out after ${timeoutMs} ms waiting for completion marker.`)
+				: "Submitted.";
+			const text = [
+				`${statusLine} ${sent.message}`,
+				output ? "" : undefined,
+				output || undefined,
+			].filter(Boolean).join("\n");
+			broadcastStudioReplToolSend({
+				toolCallId,
+				sessionName: selected.session.sessionName,
+				runtime: sent.runtime === "unknown" ? selected.session.runtime : sent.runtime,
+				code: params.code,
+				label: "Pi",
+				output,
+				completed,
+				timedOut: Boolean(sent.controlFiles?.doneFile && !completed),
+				transcript: afterTranscript,
+				capturedAt: Date.now(),
+			});
+			return {
+				content: [{ type: "text", text }],
+				details: {
+					ok: true,
+					completed,
+					timedOut: Boolean(sent.controlFiles?.doneFile && !completed),
+					timeoutMs,
+					session: selected.session,
+					sessions: selected.sessions,
+					runtime: sent.runtime,
+					usedControlFile: sent.usedControlFile,
+					submissionText: sent.submissionText,
+					controlFiles: sent.controlFiles,
+					output,
+				} as Record<string, unknown>,
+			};
+		},
+	});
+
 	const isStudioDirectRunChainActive = () => Boolean(studioDirectRunChain);
 	const getQueuedStudioSteeringCount = () => queuedStudioDirectRequests.length;
 	const getStudioClientCounts = (): { full: number; editorOnly: number } => {
@@ -8136,6 +8920,57 @@ export default function (pi: ExtensionAPI) {
 		}
 	};
 
+	const sendReplStateToClient = (client: WebSocket, extra?: Record<string, unknown>) => {
+		const state = listStudioReplSessions();
+		if (studioReplActiveSessionName && !state.sessions.some((session) => session.sessionName === studioReplActiveSessionName)) {
+			studioReplActiveSessionName = state.sessions[0]?.sessionName ?? null;
+		} else if (!studioReplActiveSessionName && state.sessions.length > 0) {
+			studioReplActiveSessionName = state.sessions[0].sessionName;
+		}
+		sendToClient(client, {
+			type: "repl_state",
+			tmuxAvailable: state.tmuxAvailable,
+			sessions: state.sessions,
+			activeSessionName: studioReplActiveSessionName,
+			error: state.error ?? null,
+			...extra,
+		});
+	};
+
+	const sendReplCaptureToClient = (client: WebSocket, sessionName?: string | null, extra?: Record<string, unknown>) => {
+		const targetSession = (typeof sessionName === "string" && sessionName.trim())
+			? sessionName.trim()
+			: studioReplActiveSessionName;
+		if (!targetSession) {
+			sendReplStateToClient(client, {
+				transcript: "",
+				capturedAt: Date.now(),
+				...extra,
+			});
+			return;
+		}
+		const captured = captureStudioReplSession(targetSession);
+		if (!captured.ok) {
+			sendReplStateToClient(client, {
+				activeSessionName: targetSession,
+				transcript: "",
+				captureError: captured.message,
+				capturedAt: Date.now(),
+				...extra,
+			});
+			return;
+		}
+		studioReplActiveSessionName = captured.session.sessionName;
+		sendToClient(client, {
+			type: "repl_capture",
+			session: captured.session,
+			activeSessionName: captured.session.sessionName,
+			transcript: captured.transcript,
+			capturedAt: Date.now(),
+			...extra,
+		});
+	};
+
 	const emitDebugEvent = (event: string, details?: Record<string, unknown>) => {
 		broadcast({
 			type: "debug_event",
@@ -8960,6 +9795,82 @@ export default function (pi: ExtensionAPI) {
 			return;
 		}
 
+		if (msg.type === "repl_list_request") {
+			sendReplStateToClient(client);
+			return;
+		}
+
+		if (msg.type === "repl_capture_request") {
+			sendReplCaptureToClient(client, msg.sessionName ?? null);
+			return;
+		}
+
+		if (msg.type === "repl_start_request") {
+			if (!isValidRequestId(msg.requestId)) {
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: "Invalid request ID." });
+				return;
+			}
+			const started = startStudioReplSession(msg.runtime, studioCwd, { newSession: msg.newSession });
+			if (!started.ok) {
+				sendReplStateToClient(client, { requestId: msg.requestId, replError: started.message });
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: started.message });
+				return;
+			}
+			studioReplActiveSessionName = started.session.sessionName;
+			sendReplStateToClient(client, { requestId: msg.requestId, replMessage: started.message });
+			sendReplCaptureToClient(client, started.session.sessionName, { requestId: msg.requestId, replMessage: started.message });
+			return;
+		}
+
+		if (msg.type === "repl_stop_request") {
+			if (!isValidRequestId(msg.requestId)) {
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: "Invalid request ID." });
+				return;
+			}
+			const stopped = stopStudioReplSession(msg.sessionName);
+			if (!stopped.ok) {
+				sendReplStateToClient(client, { requestId: msg.requestId, replError: stopped.message });
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: stopped.message });
+				return;
+			}
+			if (studioReplActiveSessionName === msg.sessionName) studioReplActiveSessionName = null;
+			sendReplStateToClient(client, { requestId: msg.requestId, replMessage: stopped.message, transcript: "", capturedAt: Date.now() });
+			return;
+		}
+
+		if (msg.type === "repl_send_request") {
+			if (!isValidRequestId(msg.requestId)) {
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: "Invalid request ID." });
+				return;
+			}
+			const sent = sendTextToStudioReplSession(msg.sessionName, msg.text);
+			if (!sent.ok) {
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: sent.message });
+				sendReplCaptureToClient(client, msg.sessionName, { requestId: msg.requestId, replError: sent.message });
+				return;
+			}
+			studioReplActiveSessionName = msg.sessionName;
+			sendToClient(client, { type: "repl_send_ack", requestId: msg.requestId, sessionName: msg.sessionName, message: sent.message });
+			setTimeout(() => sendReplCaptureToClient(client, msg.sessionName, { requestId: msg.requestId }), 150);
+			return;
+		}
+
+		if (msg.type === "repl_interrupt_request") {
+			if (!isValidRequestId(msg.requestId)) {
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: "Invalid request ID." });
+				return;
+			}
+			const interrupted = interruptStudioReplSession(msg.sessionName);
+			if (!interrupted.ok) {
+				sendToClient(client, { type: "error", requestId: msg.requestId, message: interrupted.message });
+				sendReplCaptureToClient(client, msg.sessionName, { requestId: msg.requestId, replError: interrupted.message });
+				return;
+			}
+			studioReplActiveSessionName = msg.sessionName;
+			sendReplCaptureToClient(client, msg.sessionName, { requestId: msg.requestId, replMessage: interrupted.message });
+			return;
+		}
+
 		if (msg.type === "compact_request") {
 			if (!isValidRequestId(msg.requestId)) {
 				sendToClient(client, { type: "error", requestId: msg.requestId, message: "Invalid request ID." });