pi-studio 0.9.0 → 0.9.2

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";
@@ -411,6 +412,14 @@ 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_SUBPROCESS_OUTPUT_MAX_BYTES = 2_000_000;
+const STUDIO_PANDOC_TIMEOUT_MS = readStudioPositiveEnvMs("PI_STUDIO_PANDOC_TIMEOUT_MS", 120_000, 5_000, 15 * 60_000);
+const STUDIO_LATEX_TIMEOUT_MS = readStudioPositiveEnvMs("PI_STUDIO_LATEX_TIMEOUT_MS", 120_000, 5_000, 15 * 60_000);
+const STUDIO_MERMAID_TIMEOUT_MS = readStudioPositiveEnvMs("PI_STUDIO_MERMAID_TIMEOUT_MS", 60_000, 5_000, 10 * 60_000);
+const STUDIO_HTML_RENDER_OUTPUT_MAX_BYTES = readStudioPositiveEnvMs("PI_STUDIO_HTML_RENDER_OUTPUT_MAX_BYTES", 50_000_000, 1_000_000, 500_000_000);
 const STUDIO_REPL_RUNTIME_LABELS: Record<StudioReplRuntime, string> = {
 	shell: "Shell",
 	python: "Python",
@@ -420,6 +429,16 @@ const STUDIO_REPL_RUNTIME_LABELS: Record<StudioReplRuntime, string> = {
 	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;
@@ -432,9 +451,155 @@ const STUDIO_DEFAULT_SCRATCHPAD_DOCUMENT_KEY = "doc:blank:blank";
 const STUDIO_PERSISTENT_STATE_DIR = join(getAgentDir(), "pi-studio");
 const STUDIO_PERSISTENT_STATE_PATH = join(STUDIO_PERSISTENT_STATE_DIR, "local-state.json");
 
+type StudioSubprocessResult = {
+	code: number | null;
+	signal: NodeJS.Signals | null;
+	stdout: string;
+	stderr: string;
+	stdoutTruncated: boolean;
+	stderrTruncated: boolean;
+};
+
+type StudioSubprocessOptions = {
+	cwd?: string;
+	input?: string;
+	timeoutMs?: number;
+	stdoutMaxBytes?: number;
+	stderrMaxBytes?: number;
+	notFoundMessage?: string;
+	notFoundError?: () => Error;
+	label?: string;
+};
+
+function readStudioPositiveEnvMs(name: string, fallback: number, min: number, max: number): number {
+	const parsed = Number.parseInt(String(process.env[name] ?? ""), 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return Math.max(min, Math.min(max, parsed));
+}
+
+function appendStudioSubprocessChunk(chunks: Buffer[], chunk: Buffer | string, state: { bytes: number; truncated: boolean }, maxBytes = STUDIO_SUBPROCESS_OUTPUT_MAX_BYTES): void {
+	if (state.bytes >= maxBytes) {
+		state.truncated = true;
+		return;
+	}
+	const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+	const remaining = maxBytes - state.bytes;
+	if (buffer.length <= remaining) {
+		chunks.push(buffer);
+		state.bytes += buffer.length;
+		return;
+	}
+	chunks.push(buffer.subarray(0, remaining));
+	state.bytes += remaining;
+	state.truncated = true;
+}
+
+function finalizeStudioSubprocessOutput(chunks: Buffer[], truncated: boolean): string {
+	const value = Buffer.concat(chunks).toString("utf-8").trim();
+	return truncated ? `${value}\n[output truncated by Studio]`.trim() : value;
+}
+
+function runStudioSubprocess(command: string, args: string[], options: StudioSubprocessOptions = {}): Promise<StudioSubprocessResult> {
+	return new Promise((resolvePromise, rejectPromise) => {
+		const timeoutMs = Math.max(1_000, Math.floor(options.timeoutMs ?? STUDIO_PANDOC_TIMEOUT_MS));
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			stdio: [typeof options.input === "string" ? "pipe" : "ignore", "pipe", "pipe"],
+		});
+		const stdoutChunks: Buffer[] = [];
+		const stderrChunks: Buffer[] = [];
+		const stdoutMaxBytes = Math.max(1, Math.floor(options.stdoutMaxBytes ?? STUDIO_SUBPROCESS_OUTPUT_MAX_BYTES));
+		const stderrMaxBytes = Math.max(1, Math.floor(options.stderrMaxBytes ?? STUDIO_SUBPROCESS_OUTPUT_MAX_BYTES));
+		const stdoutState = { bytes: 0, truncated: false };
+		const stderrState = { bytes: 0, truncated: false };
+		let settled = false;
+		let timedOut = false;
+		let killTimer: NodeJS.Timeout | null = null;
+
+		const cleanup = () => {
+			clearTimeout(timeoutTimer);
+			if (killTimer) clearTimeout(killTimer);
+		};
+		const fail = (error: Error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			rejectPromise(error);
+		};
+		const succeed = (result: StudioSubprocessResult) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolvePromise(result);
+		};
+		const label = options.label || basename(command) || command;
+		const timeoutTimer = setTimeout(() => {
+			timedOut = true;
+			try { child.kill("SIGTERM"); } catch {}
+			killTimer = setTimeout(() => {
+				try { child.kill("SIGKILL"); } catch {}
+			}, 2_000);
+		}, timeoutMs);
+
+		child.stdout?.on("data", (chunk: Buffer | string) => appendStudioSubprocessChunk(stdoutChunks, chunk, stdoutState, stdoutMaxBytes));
+		child.stderr?.on("data", (chunk: Buffer | string) => appendStudioSubprocessChunk(stderrChunks, chunk, stderrState, stderrMaxBytes));
+
+		child.once("error", (error) => {
+			const errno = error as NodeJS.ErrnoException;
+			if (errno.code === "ENOENT") {
+				fail(options.notFoundError ? options.notFoundError() : new Error(options.notFoundMessage || `${command} was not found.`));
+				return;
+			}
+			fail(error);
+		});
+
+		child.once("close", (code, signal) => {
+			if (timedOut) {
+				fail(new Error(`${label} timed out after ${Math.round(timeoutMs / 1000)}s.`));
+				return;
+			}
+			succeed({
+				code,
+				signal,
+				stdout: finalizeStudioSubprocessOutput(stdoutChunks, stdoutState.truncated),
+				stderr: finalizeStudioSubprocessOutput(stderrChunks, stderrState.truncated),
+				stdoutTruncated: stdoutState.truncated,
+				stderrTruncated: stderrState.truncated,
+			});
+		});
+
+		if (typeof options.input === "string") {
+			child.stdin?.end(options.input);
+		}
+	});
+}
+
+function buildStudioPandocPdfEngineOptArgs(pdfEngine: string): string[] {
+	const engineName = basename(String(pdfEngine || "")).toLowerCase();
+	if (!/^(?:pdf|xe|lua)?latex$/.test(engineName)) return [];
+	return [
+		"--pdf-engine-opt=-interaction=nonstopmode",
+		"--pdf-engine-opt=-halt-on-error",
+		"--pdf-engine-opt=-file-line-error",
+	];
+}
+
+const STUDIO_PANDOC_HTML_FRAGMENT_TEMPLATE = `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8" />
+<title>pi Studio preview</title>
+</head>
+<body>
+$body$
+</body>
+</html>
+`;
+
 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 {
@@ -4469,46 +4634,17 @@ async function renderStudioMermaidDiagramForPdf(source: string, workDir: string,
 	const outputPath = join(workDir, `mermaid-diagram-${blockNumber}.pdf`);
 
 	await writeFile(inputPath, source, "utf-8");
-	await new Promise<void>((resolve, reject) => {
-		const args = ["-i", inputPath, "-o", outputPath, "-t", mermaidTheme, "-f"];
-		const child = spawn(mermaidCommand, args, { stdio: ["ignore", "ignore", "pipe"] });
-		const stderrChunks: Buffer[] = [];
-		let settled = false;
-
-		const fail = (error: Error) => {
-			if (settled) return;
-			settled = true;
-			reject(error);
-		};
-
-		child.stderr.on("data", (chunk: Buffer | string) => {
-			stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-		});
-
-		child.once("error", (error) => {
-			const errno = error as NodeJS.ErrnoException;
-			if (errno.code === "ENOENT") {
-				fail(
-					new MermaidCliMissingError(
-						"Mermaid CLI (mmdc) not found. Install with `npm install -g @mermaid-js/mermaid-cli` or set MERMAID_CLI_PATH.",
-					),
-				);
-				return;
-			}
-			fail(error);
-		});
-
-		child.once("close", (code) => {
-			if (settled) return;
-			settled = true;
-			if (code === 0) {
-				resolve();
-				return;
-			}
-			const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-			reject(new Error(`Mermaid CLI failed with exit code ${code}${stderr ? `: ${stderr}` : ""}`));
-		});
+	const args = ["-i", inputPath, "-o", outputPath, "-t", mermaidTheme, "-f"];
+	const result = await runStudioSubprocess(mermaidCommand, args, {
+		timeoutMs: STUDIO_MERMAID_TIMEOUT_MS,
+		label: "Mermaid CLI",
+		notFoundError: () => new MermaidCliMissingError(
+			"Mermaid CLI (mmdc) not found. Install with `npm install -g @mermaid-js/mermaid-cli` or set MERMAID_CLI_PATH.",
+		),
 	});
+	if (result.code !== 0) {
+		throw new Error(`Mermaid CLI failed with exit code ${result.code}${result.stderr ? `: ${result.stderr}` : ""}`);
+	}
 
 	return outputPath;
 }
@@ -4693,82 +4829,67 @@ async function renderStudioMarkdownWithPandoc(markdown: string, isLatex?: boolea
 	const inputFormat = isLatex ? "latex" : "markdown+lists_without_preceding_blankline-blank_before_blockquote-blank_before_header+tex_math_dollars+tex_math_single_backslash+tex_math_double_backslash+autolink_bare_uris-raw_html";
 	const bibliographyArgs = buildStudioPandocBibliographyArgs(markdown, isLatex, resourcePath);
 	const args = ["-f", inputFormat, "-t", "html5", "--mathml", "--wrap=none", ...bibliographyArgs];
+	let htmlTemplateDir: string | null = null;
 	if (resourcePath) {
 		args.push(`--resource-path=${resourcePath}`);
-		// Embed images as data URIs so they render in the browser preview
-		args.push("--embed-resources", "--standalone");
+		// Embed images as data URIs so browser previews and exported HTML keep local figures.
+		// A minimal template prevents Pandoc's standalone default CSS/title block from leaking
+		// into Studio's own standalone export wrapper.
+		htmlTemplateDir = join(tmpdir(), `pi-studio-pandoc-html-${randomUUID()}`);
+		await mkdir(htmlTemplateDir, { recursive: true });
+		const htmlTemplatePath = join(htmlTemplateDir, "template.html");
+		await writeFile(htmlTemplatePath, STUDIO_PANDOC_HTML_FRAGMENT_TEMPLATE, "utf-8");
+		args.push("--embed-resources", "--standalone", `--template=${htmlTemplatePath}`);
 	}
 	const normalizedMarkdown = isLatex
 		? sourceWithResolvedRefs
 		: normalizeStudioMarkdownFencedBlocks(prepareStudioMarkdownForPandoc(sourceWithResolvedRefs));
 	const pandocWorkingDir = resolveStudioPandocWorkingDir(resourcePath);
 
-	let renderedHtml = await new Promise<string>((resolve, reject) => {
-		const child = spawn(pandocCommand, args, { stdio: ["pipe", "pipe", "pipe"], cwd: pandocWorkingDir });
-		const stdoutChunks: Buffer[] = [];
-		const stderrChunks: Buffer[] = [];
-		let settled = false;
-
-		const fail = (error: Error) => {
-			if (settled) return;
-			settled = true;
-			reject(error);
-		};
-
-		const succeed = (html: string) => {
-			if (settled) return;
-			settled = true;
-			resolve(html);
-		};
-
-		child.stdout.on("data", (chunk: Buffer | string) => {
-			stdoutChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-		});
-		child.stderr.on("data", (chunk: Buffer | string) => {
-			stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-		});
-
-		child.once("error", (error) => {
-			const errno = error as NodeJS.ErrnoException;
-			if (errno.code === "ENOENT") {
-				fail(new Error("pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary."));
-				return;
-			}
-			fail(error);
-		});
-
-		child.once("close", (code) => {
-			if (settled) return;
-			if (code === 0) {
-				let html = Buffer.concat(stdoutChunks).toString("utf-8");
-				// When --standalone was used, extract only the <body> content
-				if (resourcePath) {
-					const bodyMatch = html.match(/<body[^>]*>([\s\S]*)<\/body>/i);
-					if (bodyMatch) html = bodyMatch[1];
-				}
-				if (isLatex) {
-					html = decorateStudioLatexRenderedHtml(
-						html,
-						sourcePath,
-						resourcePath,
-						latexSubfigurePreviewTransform.subfigureGroups,
-						latexAlgorithmPreviewTransform.algorithmBlocks,
-					);
-				} else {
-					html = decorateStudioPreviewPageBreakHtml(html);
-				}
-				html = decorateStudioPandocSyntaxHtml(html);
-				succeed(stripMathMlAnnotationTags(html));
-				return;
-			}
-			const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-			fail(new Error(`pandoc failed with exit code ${code}${stderr ? `: ${stderr}` : ""}`));
+	let pandocResult: StudioSubprocessResult;
+	try {
+		pandocResult = await runStudioSubprocess(pandocCommand, args, {
+			cwd: pandocWorkingDir,
+			input: normalizedMarkdown,
+			timeoutMs: STUDIO_PANDOC_TIMEOUT_MS,
+			stdoutMaxBytes: STUDIO_HTML_RENDER_OUTPUT_MAX_BYTES,
+			label: "pandoc HTML render",
+			notFoundMessage: "pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary.",
 		});
+	} finally {
+		if (htmlTemplateDir) {
+			await rm(htmlTemplateDir, { recursive: true, force: true }).catch(() => undefined);
+		}
+	}
+	if (pandocResult.code !== 0) {
+		throw new Error(`pandoc failed with exit code ${pandocResult.code}${pandocResult.stderr ? `: ${pandocResult.stderr}` : ""}`);
+	}
+	if (pandocResult.stdoutTruncated) {
+		throw new Error(`pandoc HTML output exceeded ${Math.round(STUDIO_HTML_RENDER_OUTPUT_MAX_BYTES / 1_000_000)} MB. Reduce embedded assets or set PI_STUDIO_HTML_RENDER_OUTPUT_MAX_BYTES higher.`);
+	}
 
-		child.stdin.end(normalizedMarkdown);
-	});
-
-	return renderedHtml;
+	let renderedHtml = pandocResult.stdout;
+	// When --standalone was used for --embed-resources, extract only the <body> content.
+	if (resourcePath) {
+		const bodyMatch = renderedHtml.match(/<body[^>]*>([\s\S]*)<\/body>/i);
+		if (!bodyMatch) {
+			throw new Error("pandoc HTML render did not include a complete body element.");
+		}
+		renderedHtml = bodyMatch[1];
+	}
+	if (isLatex) {
+		renderedHtml = decorateStudioLatexRenderedHtml(
+			renderedHtml,
+			sourcePath,
+			resourcePath,
+			latexSubfigurePreviewTransform.subfigureGroups,
+			latexAlgorithmPreviewTransform.algorithmBlocks,
+		);
+	} else {
+		renderedHtml = decorateStudioPreviewPageBreakHtml(renderedHtml);
+	}
+	renderedHtml = decorateStudioPandocSyntaxHtml(renderedHtml);
+	return stripMathMlAnnotationTags(renderedHtml);
 }
 
 function escapeStudioRegExpLiteral(text: string): string {
@@ -5160,54 +5281,22 @@ ${literalPdfConfig.fontSizeCommand}\\section*{${title.replace(/[{}\\]/g, "").tri
 	await writeFile(texPath, texDocument, "utf-8");
 
 	try {
-		await new Promise<void>((resolve, reject) => {
-			const child = spawn(pdfEngine, [
-				"-interaction=nonstopmode",
-				"-halt-on-error",
-				"input.tex",
-			], { stdio: ["ignore", "pipe", "pipe"], cwd: tempDir });
-			const stdoutChunks: Buffer[] = [];
-			const stderrChunks: Buffer[] = [];
-			let settled = false;
-
-			const fail = (error: Error) => {
-				if (settled) return;
-				settled = true;
-				reject(error);
-			};
-
-			child.stdout.on("data", (chunk: Buffer | string) => {
-				stdoutChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-			});
-			child.stderr.on("data", (chunk: Buffer | string) => {
-				stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-			});
-
-			child.once("error", (error) => {
-				const errno = error as NodeJS.ErrnoException;
-				if (errno.code === "ENOENT") {
-					fail(new Error(
-						`${pdfEngine} was not found. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE.`,
-					));
-					return;
-				}
-				fail(error);
-			});
-
-			child.once("close", (code) => {
-				if (settled) return;
-				if (code === 0) {
-					settled = true;
-					resolve();
-					return;
-				}
-				const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
-				const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-				const errorMatch = stdout.match(/^! .+$/m);
-				const hint = errorMatch ? `: ${errorMatch[0]}` : (stderr ? `: ${stderr}` : "");
-				fail(new Error(`${pdfEngine} literal-text PDF export failed with exit code ${code}${hint}`));
-			});
+		const latexResult = await runStudioSubprocess(pdfEngine, [
+			"-interaction=nonstopmode",
+			"-halt-on-error",
+			"-file-line-error",
+			"input.tex",
+		], {
+			cwd: tempDir,
+			timeoutMs: STUDIO_LATEX_TIMEOUT_MS,
+			label: `${pdfEngine} literal-text PDF export`,
+			notFoundMessage: `${pdfEngine} was not found. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE.`,
 		});
+		if (latexResult.code !== 0) {
+			const errorMatch = latexResult.stdout.match(/^! .+$/m);
+			const hint = errorMatch ? `: ${errorMatch[0]}` : (latexResult.stderr ? `: ${latexResult.stderr}` : "");
+			throw new Error(`${pdfEngine} literal-text PDF export failed with exit code ${latexResult.code}${hint}`);
+		}
 
 		return await readFile(outputPath);
 	} finally {
@@ -5469,46 +5558,18 @@ async function renderStudioPdfFromGeneratedLatex(
 	const pandocSource = inputFormat === "latex" ? markdown : normalizeStudioMarkdownFencedBlocks(markdown);
 
 	try {
-		await new Promise<void>((resolve, reject) => {
-			const child = spawn(pandocCommand, pandocArgs, { stdio: ["pipe", "pipe", "pipe"], cwd: pandocWorkingDir });
-			const stderrChunks: Buffer[] = [];
-			let settled = false;
-
-			const fail = (error: Error) => {
-				if (settled) return;
-				settled = true;
-				reject(error);
-			};
-
-			child.stderr.on("data", (chunk: Buffer | string) => {
-				stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-			});
-
-			child.once("error", (error) => {
-				const errno = error as NodeJS.ErrnoException;
-				if (errno.code === "ENOENT") {
-					const commandHint = pandocCommand === "pandoc"
-						? "pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary."
-						: `${pandocCommand} was not found. Check PANDOC_PATH.`;
-					fail(new Error(commandHint));
-					return;
-				}
-				fail(error);
-			});
-
-			child.once("close", (code) => {
-				if (settled) return;
-				if (code === 0) {
-					settled = true;
-					resolve();
-					return;
-				}
-				const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-				fail(new Error(`pandoc LaTeX generation failed with exit code ${code}${stderr ? `: ${stderr}` : ""}`));
-			});
-
-			child.stdin.end(pandocSource);
+		const pandocResult = await runStudioSubprocess(pandocCommand, pandocArgs, {
+			cwd: pandocWorkingDir,
+			input: pandocSource,
+			timeoutMs: STUDIO_PANDOC_TIMEOUT_MS,
+			label: "pandoc LaTeX generation",
+			notFoundMessage: pandocCommand === "pandoc"
+				? "pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary."
+				: `${pandocCommand} was not found. Check PANDOC_PATH.`,
 		});
+		if (pandocResult.code !== 0) {
+			throw new Error(`pandoc LaTeX generation failed with exit code ${pandocResult.code}${pandocResult.stderr ? `: ${pandocResult.stderr}` : ""}`);
+		}
 
 		const generatedLatex = await readFile(latexPath, "utf-8");
 		const injectedLatex = injectStudioLatexPdfSubfigureBlocks(generatedLatex, subfigureGroups, sourcePath, resourcePath);
@@ -5519,55 +5580,23 @@ async function renderStudioPdfFromGeneratedLatex(
 		const normalizedLatex = normalizeStudioGeneratedFigureCaptions(alignedReadyLatex);
 		await writeFile(latexPath, normalizedLatex, "utf-8");
 
-		await new Promise<void>((resolve, reject) => {
-			const child = spawn(pdfEngine, [
-				"-interaction=nonstopmode",
-				"-halt-on-error",
-				`-output-directory=${tempDir}`,
-				latexPath,
-			], { stdio: ["ignore", "pipe", "pipe"], cwd: pandocWorkingDir });
-			const stdoutChunks: Buffer[] = [];
-			const stderrChunks: Buffer[] = [];
-			let settled = false;
-
-			const fail = (error: Error) => {
-				if (settled) return;
-				settled = true;
-				reject(error);
-			};
-
-			child.stdout.on("data", (chunk: Buffer | string) => {
-				stdoutChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-			});
-			child.stderr.on("data", (chunk: Buffer | string) => {
-				stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-			});
-
-			child.once("error", (error) => {
-				const errno = error as NodeJS.ErrnoException;
-				if (errno.code === "ENOENT") {
-					fail(new Error(
-						`${pdfEngine} was not found. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE.`,
-					));
-					return;
-				}
-				fail(error);
-			});
-
-			child.once("close", (code) => {
-				if (settled) return;
-				if (code === 0) {
-					settled = true;
-					resolve();
-					return;
-				}
-				const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
-				const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-				const errorMatch = stdout.match(/^! .+$/m);
-				const hint = errorMatch ? `: ${errorMatch[0]}` : (stderr ? `: ${stderr}` : "");
-				fail(new Error(`${pdfEngine} PDF export failed with exit code ${code}${hint}`));
-			});
+		const latexResult = await runStudioSubprocess(pdfEngine, [
+			"-interaction=nonstopmode",
+			"-halt-on-error",
+			"-file-line-error",
+			`-output-directory=${tempDir}`,
+			latexPath,
+		], {
+			cwd: pandocWorkingDir,
+			timeoutMs: STUDIO_LATEX_TIMEOUT_MS,
+			label: `${pdfEngine} PDF export`,
+			notFoundMessage: `${pdfEngine} was not found. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE.`,
 		});
+		if (latexResult.code !== 0) {
+			const errorMatch = latexResult.stdout.match(/^! .+$/m);
+			const hint = errorMatch ? `: ${errorMatch[0]}` : (latexResult.stderr ? `: ${latexResult.stderr}` : "");
+			throw new Error(`${pdfEngine} PDF export failed with exit code ${latexResult.code}${hint}`);
+		}
 
 		return { pdf: await readFile(outputPath) };
 	} finally {
@@ -5627,6 +5656,7 @@ async function renderStudioPdfWithPandoc(
 			"-f", inputFormat,
 			"-o", outputPath,
 			`--pdf-engine=${pdfEngine}`,
+			...buildStudioPandocPdfEngineOptArgs(pdfEngine),
 			...buildStudioPdfPandocVariableArgs(pdfOptions, inputFormat !== "latex"),
 			"-V", "urlcolor=blue",
 			"-V", "linkcolor=blue",
@@ -5636,49 +5666,22 @@ async function renderStudioPdfWithPandoc(
 		if (resourcePath) args.push(`--resource-path=${resourcePath}`);
 
 		try {
-			await new Promise<void>((resolve, reject) => {
-				const child = spawn(pandocCommand, args, { stdio: ["pipe", "pipe", "pipe"], cwd: pandocWorkingDir });
-				const stderrChunks: Buffer[] = [];
-				let settled = false;
-
-				const fail = (error: Error) => {
-					if (settled) return;
-					settled = true;
-					reject(error);
-				};
-
-				child.stderr.on("data", (chunk: Buffer | string) => {
-					stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-				});
-
-				child.once("error", (error) => {
-					const errno = error as NodeJS.ErrnoException;
-					if (errno.code === "ENOENT") {
-						const commandHint = pandocCommand === "pandoc"
-							? "pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary."
-							: `${pandocCommand} was not found. Check PANDOC_PATH.`;
-						fail(new Error(commandHint));
-						return;
-					}
-					fail(error);
-				});
-
-				child.once("close", (code) => {
-					if (settled) return;
-					if (code === 0) {
-						settled = true;
-						resolve();
-						return;
-					}
-					const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-					const hint = stderr.includes("not found") || stderr.includes("xelatex") || stderr.includes("pdflatex")
-						? "\nPDF export requires a LaTeX engine. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE."
-						: "";
-					fail(new Error(`pandoc PDF export failed with exit code ${code}${stderr ? `: ${stderr}` : ""}${hint}`));
-				});
-
-				child.stdin.end(pandocSource);
+			const pandocResult = await runStudioSubprocess(pandocCommand, args, {
+				cwd: pandocWorkingDir,
+				input: pandocSource,
+				timeoutMs: STUDIO_PANDOC_TIMEOUT_MS,
+				label: "pandoc PDF export",
+				notFoundMessage: pandocCommand === "pandoc"
+					? "pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary."
+					: `${pandocCommand} was not found. Check PANDOC_PATH.`,
 			});
+			if (pandocResult.code !== 0) {
+				const stderr = pandocResult.stderr;
+				const hint = stderr.includes("not found") || stderr.includes("xelatex") || stderr.includes("pdflatex")
+					? "\nPDF export requires a LaTeX engine. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE."
+					: "";
+				throw new Error(`pandoc PDF export failed with exit code ${pandocResult.code}${stderr ? `: ${stderr}` : ""}${hint}`);
+			}
 
 			return { pdf: await readFile(outputPath), warning };
 		} finally {
@@ -5780,6 +5783,7 @@ async function renderStudioPdfWithPandoc(
 		"-f", inputFormat,
 		"-o", outputPath,
 		`--pdf-engine=${pdfEngine}`,
+		...buildStudioPandocPdfEngineOptArgs(pdfEngine),
 		...buildStudioPdfPandocVariableArgs(pdfOptions, !isLatex),
 		"-V", "urlcolor=blue",
 		"-V", "linkcolor=blue",
@@ -5790,49 +5794,22 @@ async function renderStudioPdfWithPandoc(
 	const pandocSource = isLatex ? markdownForPdf : normalizeStudioMarkdownFencedBlocks(markdownForPdf);
 
 	try {
-		await new Promise<void>((resolve, reject) => {
-			const child = spawn(pandocCommand, args, { stdio: ["pipe", "pipe", "pipe"], cwd: pandocWorkingDir });
-			const stderrChunks: Buffer[] = [];
-			let settled = false;
-
-			const fail = (error: Error) => {
-				if (settled) return;
-				settled = true;
-				reject(error);
-			};
-
-			child.stderr.on("data", (chunk: Buffer | string) => {
-				stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-			});
-
-			child.once("error", (error) => {
-				const errno = error as NodeJS.ErrnoException;
-				if (errno.code === "ENOENT") {
-					const commandHint = pandocCommand === "pandoc"
-						? "pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary."
-						: `${pandocCommand} was not found. Check PANDOC_PATH.`;
-					fail(new Error(commandHint));
-					return;
-				}
-				fail(error);
-			});
-
-			child.once("close", (code) => {
-				if (settled) return;
-				if (code === 0) {
-					settled = true;
-					resolve();
-					return;
-				}
-				const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-				const hint = stderr.includes("not found") || stderr.includes("xelatex") || stderr.includes("pdflatex")
-					? "\nPDF export requires a LaTeX engine. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE."
-					: "";
-				fail(new Error(`pandoc PDF export failed with exit code ${code}${stderr ? `: ${stderr}` : ""}${hint}`));
-			});
-
-			child.stdin.end(pandocSource);
+		const pandocResult = await runStudioSubprocess(pandocCommand, args, {
+			cwd: pandocWorkingDir,
+			input: pandocSource,
+			timeoutMs: STUDIO_PANDOC_TIMEOUT_MS,
+			label: "pandoc PDF export",
+			notFoundMessage: pandocCommand === "pandoc"
+				? "pandoc was not found. Install pandoc or set PANDOC_PATH to the pandoc binary."
+				: `${pandocCommand} was not found. Check PANDOC_PATH.`,
 		});
+		if (pandocResult.code !== 0) {
+			const stderr = pandocResult.stderr;
+			const hint = stderr.includes("not found") || stderr.includes("xelatex") || stderr.includes("pdflatex")
+				? "\nPDF export requires a LaTeX engine. Install TeX Live (e.g. brew install --cask mactex) or set PANDOC_PDF_ENGINE."
+				: "";
+			throw new Error(`pandoc PDF export failed with exit code ${pandocResult.code}${stderr ? `: ${stderr}` : ""}${hint}`);
+		}
 
 		return { pdf: await readFile(outputPath), warning: mermaidPrepared.warning };
 	} finally {
@@ -7031,7 +7008,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 {
@@ -7158,6 +7135,23 @@ function listStudioReplSessions(): { tmuxAvailable: boolean; sessions: StudioRep
 	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);
@@ -7168,9 +7162,9 @@ function captureStudioReplSession(sessionName: string): { ok: true; transcript:
 		label: formatStudioReplSessionLabel(sessionName, inferred.runtime, inferred.source),
 		source: inferred.source,
 	};
-	const result = runStudioTmux(["capture-pane", "-p", "-t", session.target, "-S", `-${STUDIO_REPL_CAPTURE_LINES}`], { timeout: 3_000 });
+	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: result.stdout.replace(/[\t ]+$/gm, "").trimEnd(), session };
+	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 } {
@@ -7218,32 +7212,298 @@ function stopStudioReplSession(sessionName: string): { ok: true; message: string
 	return { ok: true, message: `Stopped ${sessionName}.` };
 }
 
-function prepareTextForStudioReplSend(sessionName: string, source: string): string {
-	const normalized = String(source || "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+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 === "python" || runtime === "ipython") && normalized.includes("\n")) {
-		// The standard Python prompt needs a final blank line to close pasted suites
-		// such as `for`/`if`/`def` blocks. Without it the prompt can remain in
-		// continuation mode, making the next send look like an unexpected indent.
-		return `${normalized.replace(/\n+$/, "")}\n\n`;
+	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 normalized.endsWith("\n") ? normalized : `${normalized}\n`;
+
+	return {
+		runtime,
+		usedControlFile: false,
+		submissionText: normalizedSource.replace(/\n+$/, ""),
+	};
 }
 
-function sendTextToStudioReplSession(sessionName: string, text: string): { ok: true; message: string } | { ok: false; message: string } {
+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 bufferName = `pi-studio-repl-${randomUUID().replace(/-/g, "")}`;
-	const input = prepareTextForStudioReplSend(sessionName, source);
-	const loadResult = runStudioTmux(["load-buffer", "-b", bufferName, "-"], { input, timeout: 5_000 });
-	if (!loadResult.ok) return { ok: false, message: loadResult.message || "Failed to load text into tmux buffer." };
-	const pasteResult = runStudioTmux(["paste-buffer", "-d", "-b", bufferName, "-t", getStudioReplPaneTarget(sessionName)], { timeout: 5_000 });
-	if (!pasteResult.ok) return { ok: false, message: pasteResult.message || "Failed to paste text into REPL session." };
-	return { ok: true, message: `Sent ${source.length} chars to ${sessionName}.` };
+	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 } {
@@ -7708,6 +7968,7 @@ ${cssVarsBlock}
       <label class="file-label" title="Load a local file into editor text.">Load file content<input id="fileInput" type="file" accept=".md,.markdown,.mdx,.qmd,.js,.mjs,.cjs,.jsx,.ts,.mts,.cts,.tsx,.py,.pyw,.sh,.bash,.zsh,.json,.jsonc,.json5,.rs,.c,.h,.cpp,.cxx,.cc,.hpp,.hxx,.jl,.f90,.f95,.f03,.f,.for,.r,.R,.m,.tex,.latex,.diff,.patch,.java,.go,.rb,.swift,.html,.htm,.css,.xml,.yaml,.yml,.toml,.lua,.txt,.rst,.adoc" /></label>
       <button id="loadGitDiffBtn" type="button" title="Load the current git diff from the Studio context into the editor.">Load git diff</button>
       <button id="getEditorBtn" type="button" title="Load the current terminal editor draft into Studio.">Load from pi editor</button>
+      <button id="zenModeBtn" class="zen-mode-btn" type="button" title="Hide secondary Studio controls.">⊙ Zen</button>
     </div>
   </header>
 
@@ -7745,8 +8006,8 @@ ${cssVarsBlock}
               <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="scratch" selected>Scratch send</option>
-                <option value="literate">Literate send</option>
+                <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>
@@ -8032,6 +8293,164 @@ export default function (pi: ExtensionAPI) {
 	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 } => {
@@ -11408,6 +11827,7 @@ export default function (pi: ExtensionAPI) {
 				const outputPath = buildStudioResponseExportOutputPath(ctx.cwd, "pdf");
 
 				try {
+					ctx.ui.notify("Exporting last response Studio PDF…", "info");
 					const { pdf, warning } = await renderStudioPdfWithPandoc(
 						response.markdown,
 						isLatex,
@@ -11465,6 +11885,7 @@ export default function (pi: ExtensionAPI) {
 			const outputPath = buildStudioPdfOutputPath(file.resolvedPath);
 
 			try {
+				ctx.ui.notify(`Exporting Studio PDF: ${outputPath}`, "info");
 				const { pdf, warning } = await renderStudioPdfWithPandoc(
 					file.text,
 					isLatex,