pi-studio 0.9.23 → 0.9.24

package/index.ts

@@ -458,8 +458,8 @@ interface GetFromEditorRequestMessage {
 	requestId: string;
 }
 
-interface LoadGitDiffRequestMessage {
-	type: "load_git_diff_request";
+interface GitChangesRequestMessage {
+	type: "git_changes_request";
 	requestId: string;
 	sourcePath?: string;
 	resourceDir?: string;
@@ -504,7 +504,7 @@ type IncomingStudioMessage =
 	| RefreshFromDiskRequestMessage
 	| SendToEditorRequestMessage
 	| GetFromEditorRequestMessage
-	| LoadGitDiffRequestMessage
+	| GitChangesRequestMessage
 	| OpenEditorOnlyRequestMessage
 	| CancelRequestMessage;
 
@@ -569,6 +569,46 @@ 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 STUDIO_EXPORT_INPUT_FORMAT_DESCRIPTION = "Optional input format: auto, markdown, or latex. Defaults to auto.";
+const STUDIO_EXPORT_PDF_OPTIONS_TOOL_PARAMS = Type.Object({
+	fontsize: Type.Optional(Type.String({ description: "PDF body font size, e.g. 12pt." })),
+	margin: Type.Optional(Type.String({ description: "PDF page margin, e.g. 25mm." })),
+	marginTop: Type.Optional(Type.String({ description: "PDF top margin, e.g. 30mm." })),
+	marginRight: Type.Optional(Type.String({ description: "PDF right margin, e.g. 25mm." })),
+	marginBottom: Type.Optional(Type.String({ description: "PDF bottom margin, e.g. 30mm." })),
+	marginLeft: Type.Optional(Type.String({ description: "PDF left margin, e.g. 25mm." })),
+	footskip: Type.Optional(Type.String({ description: "PDF footer skip, e.g. 12mm." })),
+	linestretch: Type.Optional(Type.String({ description: "PDF line stretch, e.g. 1.2." })),
+	mainfont: Type.Optional(Type.String({ description: "PDF main font, e.g. TeX Gyre Pagella." })),
+	papersize: Type.Optional(Type.String({ description: "PDF paper size, e.g. a4 or letter." })),
+	geometry: Type.Optional(Type.String({ description: "Pandoc geometry spec. Use instead of margin fields." })),
+	sectionSize: Type.Optional(Type.String({ description: "PDF section heading size, e.g. 24pt." })),
+	subsectionSize: Type.Optional(Type.String({ description: "PDF subsection heading size, e.g. 18pt." })),
+	subsubsectionSize: Type.Optional(Type.String({ description: "PDF subsubsection heading size, e.g. 14pt." })),
+	sectionSpaceBefore: Type.Optional(Type.String({ description: "Space before section headings, e.g. 10mm." })),
+	sectionSpaceAfter: Type.Optional(Type.String({ description: "Space after section headings, e.g. 6mm." })),
+	subsectionSpaceBefore: Type.Optional(Type.String({ description: "Space before subsection headings, e.g. 8mm." })),
+	subsectionSpaceAfter: Type.Optional(Type.String({ description: "Space after subsection headings, e.g. 4mm." })),
+});
+const STUDIO_EXPORT_PDF_TOOL_PARAMS = Type.Object({
+	path: Type.Optional(Type.String({ description: "Local Markdown/LaTeX/code file to export. Omit to export markdown or the last model response." })),
+	markdown: Type.Optional(Type.String({ description: "Markdown or LaTeX content to export directly. Omit when exporting a file or the last model response." })),
+	outputPath: Type.Optional(Type.String({ description: "Output PDF path. Relative paths resolve against the current working directory." })),
+	resourceDir: Type.Optional(Type.String({ description: "Base directory for resolving relative images/assets when exporting direct markdown." })),
+	title: Type.Optional(Type.String({ description: "Title/source label for direct markdown exports." })),
+	inputFormat: Type.Optional(Type.String({ description: STUDIO_EXPORT_INPUT_FORMAT_DESCRIPTION })),
+	open: Type.Optional(Type.Boolean({ description: "Open the exported PDF locally after writing it. Defaults to false for tool use." })),
+	pdfOptions: Type.Optional(STUDIO_EXPORT_PDF_OPTIONS_TOOL_PARAMS),
+});
+const STUDIO_EXPORT_HTML_TOOL_PARAMS = Type.Object({
+	path: Type.Optional(Type.String({ description: "Local Markdown/LaTeX/code file to export. Omit to export markdown or the last model response." })),
+	markdown: Type.Optional(Type.String({ description: "Markdown or LaTeX content to export directly. Omit when exporting a file or the last model response." })),
+	outputPath: Type.Optional(Type.String({ description: "Output HTML path. Relative paths resolve against the current working directory." })),
+	resourceDir: Type.Optional(Type.String({ description: "Base directory for resolving relative images/assets when exporting direct markdown." })),
+	title: Type.Optional(Type.String({ description: "HTML document title/source label for direct markdown exports." })),
+	inputFormat: Type.Optional(Type.String({ description: STUDIO_EXPORT_INPUT_FORMAT_DESCRIPTION })),
+	open: Type.Optional(Type.Boolean({ description: "Open the exported HTML locally after writing it. Defaults to false for tool use." })),
+});
 const MAX_STUDIO_TRACE_SNAPSHOTS = RESPONSE_HISTORY_LIMIT;
 const TRANSIENT_STUDIO_DOCUMENT_TTL_MS = 30 * 60 * 1000;
 const MAX_TRANSIENT_STUDIO_DOCUMENTS = 16;
@@ -2484,6 +2524,62 @@ function buildStudioSyntheticNewFileDiff(filePath: string, content: string): str
 	return diffLines.join("\n");
 }
 
+interface StudioGitChangedFile {
+	path: string;
+	oldPath?: string;
+	status: "modified" | "added" | "deleted" | "renamed" | "untracked" | "binary";
+	additions: number;
+	deletions: number;
+	diff: string;
+}
+
+function unquoteStudioGitPath(path: string): string {
+	const value = String(path ?? "").trim();
+	if (!value.startsWith('"') || !value.endsWith('"')) return value;
+	try {
+		return JSON.parse(value) as string;
+	} catch {
+		return value.slice(1, -1);
+	}
+}
+
+function summarizeStudioGitDiffFiles(diffText: string, untrackedPaths: Set<string>): StudioGitChangedFile[] {
+	const matches = Array.from(String(diffText ?? "").matchAll(/^diff --git a\/(.*?) b\/(.*?)$/gm));
+	const files: StudioGitChangedFile[] = [];
+	for (let i = 0; i < matches.length; i += 1) {
+		const match = matches[i]!;
+		const start = match.index ?? 0;
+		const end = i + 1 < matches.length ? (matches[i + 1]!.index ?? diffText.length) : diffText.length;
+		const section = diffText.slice(start, end).trimEnd();
+		const oldPath = unquoteStudioGitPath(match[1] ?? "");
+		let path = unquoteStudioGitPath(match[2] ?? oldPath);
+		const renameTo = section.match(/^rename to\s+(.+)$/m);
+		if (renameTo) path = unquoteStudioGitPath(renameTo[1] ?? path);
+		let status: StudioGitChangedFile["status"] = "modified";
+		if (untrackedPaths.has(path)) status = "untracked";
+		else if (/^rename from\s+/m.test(section) || /^rename to\s+/m.test(section)) status = "renamed";
+		else if (/^deleted file mode\s+/m.test(section) || /^\+\+\+ \/dev\/null$/m.test(section)) status = "deleted";
+		else if (/^new file mode\s+/m.test(section) || /^--- \/dev\/null$/m.test(section)) status = "added";
+		else if (/^Binary files\s+/m.test(section)) status = "binary";
+		let additions = 0;
+		let deletions = 0;
+		for (const line of section.split("\n")) {
+			if (line.startsWith("+++") || line.startsWith("---")) continue;
+			if (line.startsWith("+")) additions += 1;
+			else if (line.startsWith("-")) deletions += 1;
+		}
+		files.push({
+			path,
+			oldPath: oldPath && oldPath !== path ? oldPath : undefined,
+			status,
+			additions,
+			deletions,
+			diff: section,
+		});
+	}
+	return files;
+}
+
 function resolveStudioBaseDir(sourcePath: string | undefined, resourceDir: string | undefined, fallbackCwd: string): string {
 	const source = typeof sourcePath === "string" ? sourcePath.trim() : "";
 	if (source) {
@@ -4006,7 +4102,7 @@ function injectStudioLatexEquationTags(markdown: string, sourcePath: string | un
 }
 
 function readStudioGitDiff(baseDir: string):
-	| { ok: true; text: string; label: string }
+	| { ok: true; text: string; label: string; repoRoot: string; branch: string; hasHead: boolean; files: StudioGitChangedFile[] }
 	| { ok: false; level: "info" | "warning" | "error"; message: string } {
 	const repoRootArgs = ["rev-parse", "--show-toplevel"];
 	const repoRootResult = spawnSync("git", repoRootArgs, {
@@ -4021,11 +4117,24 @@ function readStudioGitDiff(baseDir: string):
 		};
 	}
 	const repoRoot = repoRootResult.stdout.trim();
+	const branchResult = spawnSync("git", ["branch", "--show-current"], {
+		cwd: repoRoot,
+		encoding: "utf-8",
+	});
+	let branch = branchResult.status === 0 ? branchResult.stdout.trim() : "";
 
 	const hasHead = spawnSync("git", ["rev-parse", "--verify", "HEAD"], {
 		cwd: repoRoot,
 		encoding: "utf-8",
 	}).status === 0;
+	if (!branch && hasHead) {
+		const revResult = spawnSync("git", ["rev-parse", "--short", "HEAD"], {
+			cwd: repoRoot,
+			encoding: "utf-8",
+		});
+		branch = revResult.status === 0 && revResult.stdout.trim() ? `detached ${revResult.stdout.trim()}` : "detached HEAD";
+	}
+	if (!branch) branch = "unknown branch";
 
 	const untrackedArgs = ["ls-files", "--others", "--exclude-standard"];
 	const untrackedResult = spawnSync("git", untrackedArgs, {
@@ -4128,7 +4237,8 @@ function readStudioGitDiff(baseDir: string):
 
 	const labelBase = hasHead ? "git diff HEAD" : "git diff (no commits yet)";
 	const label = summaryParts.length > 0 ? `${labelBase} (${summaryParts.join(", ")})` : labelBase;
-	return { ok: true, text: fullDiff, label };
+	const files = summarizeStudioGitDiffFiles(fullDiff, new Set(untrackedPaths));
+	return { ok: true, text: fullDiff, label, repoRoot, branch, hasHead, files };
 }
 
 function isLikelyMathExpression(expr: string): boolean {
@@ -8245,13 +8355,13 @@ function parseIncomingMessage(data: RawData): IncomingStudioMessage | null {
 	}
 
 	if (
-		msg.type === "load_git_diff_request"
+		msg.type === "git_changes_request"
 		&& typeof msg.requestId === "string"
 		&& (msg.sourcePath === undefined || typeof msg.sourcePath === "string")
 		&& (msg.resourceDir === undefined || typeof msg.resourceDir === "string")
 	) {
 		return {
-			type: "load_git_diff_request",
+			type: "git_changes_request",
 			requestId: msg.requestId,
 			sourcePath: typeof msg.sourcePath === "string" ? msg.sourcePath : undefined,
 			resourceDir: typeof msg.resourceDir === "string" ? msg.resourceDir : undefined,
@@ -9942,7 +10052,6 @@ ${cssVarsBlock}
       <button id="refreshFromDiskBtn" type="button" title="Reload the current file-backed document from disk.">Refresh from disk</button>
       <button id="clearWorkspaceBtn" type="button" title="Clear editor text and reset this tab to a fresh blank draft. Saved files and responses are not changed.">Reset editor</button>
       <label class="file-label" title="Import a browser-selected text file into the editor as an unsaved copy. It will not be refreshable from disk until you save it.">Import file copy…<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. Shortcut: F9.">Zen</button>
     </div>
@@ -10152,6 +10261,7 @@ ${cssVarsBlock}
             <option value="preview" selected>Response (Preview)</option>
             <option value="editor-preview">Editor (Preview)</option>
             <option value="trace">Working</option>
+            <option value="changes">Changes</option>
             <option value="files">Files</option>
             <option value="repl">REPL</option>
           </select>
@@ -10201,10 +10311,10 @@ ${cssVarsBlock}
           </div>
           <div class="response-actions-row history-row">
             <button id="pullLatestBtn" type="button" title="Fetch the latest assistant response when auto-update is off.">Fetch latest response</button>
-            <button id="historyPrevBtn" type="button" title="Show previous response in history.">◀ Prev response</button>
-            <span id="historyIndexBadge" class="source-badge">History: 0/0</span>
-            <button id="historyNextBtn" type="button" title="Show next response in history.">Next response ▶</button>
-            <button id="historyLastBtn" type="button" title="Jump to the latest loaded response in history.">Last response ▶|</button>
+            <button id="historyPrevBtn" type="button" title="Show previous response in the current branch history.">◀ Prev response</button>
+            <span id="historyIndexBadge" class="source-badge">Branch history: 0/0</span>
+            <button id="historyNextBtn" type="button" title="Show next response in the current branch history.">Next response ▶</button>
+            <button id="historyLastBtn" type="button" title="Jump to the latest loaded response in the current branch history.">Last response ▶|</button>
           </div>
           <div class="response-actions-row response-result-row">
             <button id="loadResponseBtn" type="button">Load response into editor</button>
@@ -10299,7 +10409,7 @@ ${cssVarsBlock}
       <div class="scratchpad-footer">
         <span id="scratchpadMeta" class="scratchpad-meta">Empty · local only</span>
         <div class="scratchpad-actions">
-          <button id="scratchpadRecentBtn" type="button" title="Show recent non-empty scratchpads saved for other files and drafts.">Recent…</button>
+          <button id="scratchpadRecentBtn" type="button" aria-expanded="false" title="Show recent non-empty scratchpads saved for other files and drafts.">Recent…</button>
           <button id="scratchpadInsertBtn" type="button" title="Insert the scratchpad text into the editor at the current selection, or append it if no editor selection is available.">Insert into editor</button>
           <button id="scratchpadCopyBtn" type="button" title="Copy scratchpad text to the clipboard.">Copy</button>
           <button id="scratchpadClearBtn" type="button" title="Clear scratchpad text.">Clear</button>
@@ -10532,6 +10642,48 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerTool({
+		name: "studio_export_pdf",
+		label: "Studio PDF export",
+		description: "Export Markdown/LaTeX content, a local file, or the last model response to PDF using the Studio PDF pipeline.",
+		promptSnippet: "Export Markdown/LaTeX, a local file, or the last model response to PDF with Studio's PDF pipeline.",
+		promptGuidelines: [
+			"Use studio_export_pdf when the user asks to make/export/render content as a PDF using Studio.",
+			"For remote or Telegram sessions, leave open=false and report the generated file path unless a separate upload/send-file tool is available.",
+			"Pass markdown directly when exporting content composed in the current assistant turn; omit markdown and path only when exporting the previous model response.",
+		],
+		parameters: STUDIO_EXPORT_PDF_TOOL_PARAMS,
+		executionMode: "sequential",
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const result = await exportStudioPdfForTool(params, ctx);
+			return {
+				content: [{ type: "text", text: formatStudioExportToolText(result) }],
+				details: result as Record<string, unknown>,
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "studio_export_html",
+		label: "Studio HTML export",
+		description: "Export Markdown/LaTeX content, a local file, or the last model response to standalone HTML using the Studio preview pipeline.",
+		promptSnippet: "Export Markdown/LaTeX, a local file, or the last model response to standalone HTML with Studio's preview pipeline.",
+		promptGuidelines: [
+			"Use studio_export_html when the user asks to make/export/render content as HTML using Studio.",
+			"For remote or Telegram sessions, leave open=false and report the generated file path unless a separate upload/send-file tool is available.",
+			"Pass markdown directly when exporting content composed in the current assistant turn; omit markdown and path only when exporting the previous model response.",
+		],
+		parameters: STUDIO_EXPORT_HTML_TOOL_PARAMS,
+		executionMode: "sequential",
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const result = await exportStudioHtmlForTool(params, ctx);
+			return {
+				content: [{ type: "text", text: formatStudioExportToolText(result) }],
+				details: result as Record<string, unknown>,
+			};
+		},
+	});
+
 	const isStudioDirectRunChainActive = () => Boolean(studioDirectRunChain);
 	const getQueuedStudioSteeringCount = () => queuedStudioDirectRequests.length;
 	const getStudioClientCounts = (): { full: number; editorOnly: number } => {
@@ -11635,39 +11787,33 @@ export default function (pi: ExtensionAPI) {
 			return;
 		}
 
-		if (msg.type === "load_git_diff_request") {
+		if (msg.type === "git_changes_request") {
 			if (!isValidRequestId(msg.requestId)) {
 				sendToClient(client, { type: "error", requestId: msg.requestId, message: "Invalid request ID." });
 				return;
 			}
-			if (isStudioBusy()) {
-				sendToClient(client, { type: "busy", requestId: msg.requestId, message: "Studio is busy." });
-				return;
-			}
-
 			const baseDir = resolveStudioGitDiffBaseDir(msg.sourcePath, msg.resourceDir, studioCwd);
 			const diffResult = readStudioGitDiff(baseDir);
 			if (diffResult.ok === false) {
 				sendToClient(client, {
-					type: "info",
+					type: "git_changes_snapshot",
 					requestId: msg.requestId,
+					ok: false,
 					message: diffResult.message,
 					level: diffResult.level,
 				});
 				return;
 			}
-
-			initialStudioDocument = {
-				text: diffResult.text,
-				label: diffResult.label,
-				source: "blank",
-			};
 			sendToClient(client, {
-				type: "git_diff_snapshot",
+				type: "git_changes_snapshot",
 				requestId: msg.requestId,
+				ok: true,
 				content: diffResult.text,
 				label: diffResult.label,
-				message: "Loaded current git diff into Studio.",
+				repoRoot: diffResult.repoRoot,
+				branch: diffResult.branch,
+				hasHead: diffResult.hasHead,
+				files: diffResult.files,
 			});
 			return;
 		}
@@ -13865,7 +14011,7 @@ export default function (pi: ExtensionAPI) {
 			type: "info",
 			level: "info",
 			message: studioResponseHistory.length > 0
-				? "Pi session tree changed; Studio response history now follows the current branch. Editor text was left unchanged."
+				? "Pi session tree changed; Studio branch history now follows the current branch. Editor text was left unchanged."
 				: "Pi session tree changed; this branch has no assistant responses yet. Editor text was left unchanged.",
 		});
 	});
@@ -14265,7 +14411,7 @@ export default function (pi: ExtensionAPI) {
 		};
 	};
 
-	const resolveLastModelResponseForExport = (ctx: ExtensionCommandContext): { markdown: string } | null => {
+	const resolveLastModelResponseForExport = (ctx: ExtensionContext): { markdown: string } | null => {
 		const branchEntries = ctx.sessionManager.getBranch();
 		syncStudioResponseHistory(branchEntries);
 		const markdown =
@@ -14276,6 +14422,244 @@ export default function (pi: ExtensionAPI) {
 		return markdown.trim() ? { markdown } : null;
 	};
 
+	type StudioExportInputFormat = "auto" | "markdown" | "latex";
+	type StudioExportCommonToolParams = {
+		path?: string;
+		markdown?: string;
+		outputPath?: string;
+		resourceDir?: string;
+		title?: string;
+		inputFormat?: string;
+		open?: boolean;
+	};
+	type StudioExportPdfToolParams = StudioExportCommonToolParams & { pdfOptions?: StudioPdfRenderOptions };
+	type StudioExportSource = {
+		text: string;
+		sourceLabel: string;
+		sourcePath?: string;
+		resourcePath: string;
+		outputPath: string;
+		inputFormat: StudioExportInputFormat;
+	};
+	type StudioExportResult = {
+		ok: boolean;
+		format: "pdf" | "html";
+		path?: string;
+		source?: string;
+		bytes?: number;
+		warning?: string;
+		openError?: string;
+		error?: string;
+	};
+
+	const parseStudioExportInputFormat = (value: unknown): StudioExportInputFormat | { error: string } => {
+		const normalized = String(value ?? "auto").trim().toLowerCase();
+		if (!normalized || normalized === "auto") return "auto";
+		if (normalized === "markdown" || normalized === "md") return "markdown";
+		if (normalized === "latex" || normalized === "tex") return "latex";
+		return { error: "Invalid inputFormat. Use auto, markdown, or latex." };
+	};
+
+	const resolveStudioExportOutputPath = (outputPath: string | undefined, cwd: string): string | null => {
+		const raw = typeof outputPath === "string" ? outputPath.trim() : "";
+		if (!raw) return null;
+		const resolved = resolveStudioPath(raw, cwd);
+		return resolved.ok ? resolved.resolved : null;
+	};
+
+	const validateStudioPdfOptionsForTool = (input: StudioPdfRenderOptions | undefined): StudioPdfRenderOptions | { error: string } => {
+		if (!input || typeof input !== "object") return {};
+		const options: StudioPdfRenderOptions = {};
+		const setOption = (key: keyof StudioPdfRenderOptions, value: string) => {
+			(options as Record<string, string>)[key] = value;
+		};
+		const requireLength = (key: keyof StudioPdfRenderOptions, label: string, example: string): { error: string } | null => {
+			const value = String(input[key] ?? "").trim();
+			if (!value) return null;
+			if (!isValidStudioPdfLength(value)) return { error: `Invalid ${label} value. Example: ${example}` };
+			setOption(key, value);
+			return null;
+		};
+		for (const [key, label, example] of [
+			["fontsize", "fontsize", "12pt"],
+			["sectionSize", "sectionSize", "24pt"],
+			["subsectionSize", "subsectionSize", "18pt"],
+			["subsubsectionSize", "subsubsectionSize", "14pt"],
+			["sectionSpaceBefore", "sectionSpaceBefore", "10mm"],
+			["sectionSpaceAfter", "sectionSpaceAfter", "6mm"],
+			["subsectionSpaceBefore", "subsectionSpaceBefore", "8mm"],
+			["subsectionSpaceAfter", "subsectionSpaceAfter", "4mm"],
+			["margin", "margin", "25mm"],
+			["marginTop", "marginTop", "30mm"],
+			["marginRight", "marginRight", "25mm"],
+			["marginBottom", "marginBottom", "30mm"],
+			["marginLeft", "marginLeft", "25mm"],
+			["footskip", "footskip", "12mm"],
+		] as Array<[keyof StudioPdfRenderOptions, string, string]>) {
+			const error = requireLength(key, label, example);
+			if (error) return error;
+		}
+		const linestretch = String(input.linestretch ?? "").trim();
+		if (linestretch) {
+			if (!isValidStudioPdfLineStretch(linestretch)) return { error: "Invalid linestretch value. Example: 1.2" };
+			options.linestretch = linestretch;
+		}
+		const papersize = String(input.papersize ?? "").trim();
+		if (papersize) {
+			if (!isValidStudioPdfPaperSize(papersize)) return { error: "Invalid papersize value. Example: a4" };
+			options.papersize = papersize;
+		}
+		const mainfont = sanitizeStudioPdfFreeformOption(String(input.mainfont ?? ""));
+		if (mainfont) options.mainfont = mainfont;
+		const geometry = sanitizeStudioPdfFreeformOption(String(input.geometry ?? ""));
+		if (geometry) options.geometry = geometry;
+		if (options.geometry && (options.margin || options.marginTop || options.marginRight || options.marginBottom || options.marginLeft || options.footskip)) {
+			return { error: "Use either geometry or the margin/margin*/footskip options, not both." };
+		}
+		return options;
+	};
+
+	const resolveStudioExportSource = (
+		params: StudioExportCommonToolParams,
+		ctx: ExtensionContext,
+		format: "pdf" | "html",
+	): StudioExportSource | { error: string } => {
+		const inputFormat = parseStudioExportInputFormat(params.inputFormat);
+		if (typeof inputFormat !== "string") return inputFormat;
+		const pathArg = String(params.path ?? "").trim();
+		const directMarkdown = typeof params.markdown === "string" ? params.markdown : "";
+		const hasDirectMarkdown = directMarkdown.trim().length > 0;
+		if (pathArg && hasDirectMarkdown) return { error: "Use either path or markdown, not both." };
+
+		if (hasDirectMarkdown) {
+			const outputPath = resolveStudioExportOutputPath(params.outputPath, ctx.cwd)
+				?? buildStudioResponseExportOutputPath(ctx.cwd, format);
+			const title = String(params.title ?? "").trim();
+			return {
+				text: directMarkdown,
+				sourceLabel: title || "provided markdown",
+				resourcePath: resolveStudioBaseDir(undefined, params.resourceDir, ctx.cwd),
+				outputPath,
+				inputFormat,
+			};
+		}
+
+		if (pathArg) {
+			const file = readStudioFile(pathArg, ctx.cwd);
+			if (file.ok === false) return { error: file.message };
+			const outputPath = resolveStudioExportOutputPath(params.outputPath, ctx.cwd)
+				?? (format === "pdf" ? buildStudioPdfOutputPath(file.resolvedPath) : buildStudioHtmlOutputPath(file.resolvedPath));
+			return {
+				text: file.text,
+				sourceLabel: file.label,
+				sourcePath: file.resolvedPath,
+				resourcePath: resolveStudioBaseDir(file.resolvedPath, params.resourceDir, ctx.cwd),
+				outputPath,
+				inputFormat,
+			};
+		}
+
+		const response = resolveLastModelResponseForExport(ctx);
+		if (!response) return { error: "No last model response to export. Provide path or markdown, or run a prompt first." };
+		return {
+			text: response.markdown,
+			sourceLabel: "last model response",
+			resourcePath: resolveStudioBaseDir(undefined, params.resourceDir, ctx.cwd),
+			outputPath: resolveStudioExportOutputPath(params.outputPath, ctx.cwd) ?? buildStudioResponseExportOutputPath(ctx.cwd, format),
+			inputFormat,
+		};
+	};
+
+	const resolveStudioExportLanguage = (source: StudioExportSource): string | undefined => {
+		if (source.inputFormat === "latex") return "latex";
+		if (source.inputFormat === "markdown") return "markdown";
+		return (source.sourcePath ? inferStudioPdfLanguageFromPath(source.sourcePath) : undefined)
+			?? inferStudioPdfLanguage(source.text);
+	};
+
+	const maybeOpenStudioExportPath = async (path: string, open: boolean | undefined): Promise<string | null> => {
+		if (!open) return null;
+		try {
+			await openPathInDefaultViewer(path);
+			return null;
+		} catch (error) {
+			return error instanceof Error ? error.message : String(error);
+		}
+	};
+
+	const formatStudioExportToolText = (result: StudioExportResult): string => {
+		if (!result.ok) return result.error ?? "Studio export failed.";
+		const lines = [`Exported Studio ${result.format.toUpperCase()}: ${result.path}`];
+		if (result.source) lines.push(`Source: ${result.source}`);
+		if (result.bytes != null) lines.push(`Bytes: ${result.bytes}`);
+		if (result.warning) lines.push(`Warning: ${result.warning}`);
+		if (result.openError) lines.push(`Open warning: ${result.openError}`);
+		return lines.join("\n");
+	};
+
+	const exportStudioPdfForTool = async (params: StudioExportPdfToolParams, ctx: ExtensionContext): Promise<StudioExportResult> => {
+		const source = resolveStudioExportSource(params, ctx, "pdf");
+		if ("error" in source) return { ok: false, format: "pdf", error: source.error };
+		if (source.text.length > PDF_EXPORT_MAX_CHARS) return { ok: false, format: "pdf", error: `PDF export text exceeds ${PDF_EXPORT_MAX_CHARS} characters.` };
+		const pdfOptions = validateStudioPdfOptionsForTool(params.pdfOptions);
+		if ("error" in pdfOptions) return { ok: false, format: "pdf", error: pdfOptions.error };
+		const editorPdfLanguage = resolveStudioExportLanguage(source);
+		const isLatex = editorPdfLanguage === "latex"
+			|| (
+				source.inputFormat !== "markdown"
+				&& (editorPdfLanguage === undefined || editorPdfLanguage === "markdown")
+				&& /\\documentclass\b|\\begin\{document\}/.test(source.text)
+			);
+		try {
+			const { pdf, warning } = await renderStudioPdfWithPandoc(
+				source.text,
+				isLatex,
+				source.resourcePath,
+				editorPdfLanguage,
+				source.sourcePath,
+				pdfOptions,
+			);
+			await writeFile(source.outputPath, pdf);
+			const openError = await maybeOpenStudioExportPath(source.outputPath, params.open);
+			return { ok: true, format: "pdf", path: source.outputPath, source: source.sourceLabel, bytes: pdf.length, warning, openError: openError ?? undefined };
+		} catch (error) {
+			return { ok: false, format: "pdf", error: `Studio PDF export failed: ${error instanceof Error ? error.message : String(error)}` };
+		}
+	};
+
+	const exportStudioHtmlForTool = async (params: StudioExportCommonToolParams, ctx: ExtensionContext): Promise<StudioExportResult> => {
+		const source = resolveStudioExportSource(params, ctx, "html");
+		if ("error" in source) return { ok: false, format: "html", error: source.error };
+		if (source.text.length > HTML_EXPORT_MAX_CHARS) return { ok: false, format: "html", error: `HTML export text exceeds ${HTML_EXPORT_MAX_CHARS} characters.` };
+		const editorHtmlLanguage = resolveStudioExportLanguage(source);
+		const isLatex = editorHtmlLanguage === "latex"
+			|| (
+				source.inputFormat !== "markdown"
+				&& (editorHtmlLanguage === undefined || editorHtmlLanguage === "markdown")
+				&& isLikelyStandaloneLatexPreview(source.text)
+			);
+		try {
+			const themeVars = buildThemeCssVars(getStudioThemeStyle(ctx.ui.theme));
+			const { html, warning } = await renderStudioStandaloneHtmlWithPandoc(
+				source.text,
+				isLatex,
+				source.resourcePath,
+				editorHtmlLanguage,
+				source.sourcePath,
+				{
+					title: String(params.title ?? "").trim() || basename(source.outputPath),
+					sourceLabel: source.sourcePath ?? source.sourceLabel,
+					themeVars,
+				},
+			);
+			await writeFile(source.outputPath, html);
+			const openError = await maybeOpenStudioExportPath(source.outputPath, params.open);
+			return { ok: true, format: "html", path: source.outputPath, source: source.sourceLabel, bytes: html.length, warning, openError: openError ?? undefined };
+		} catch (error) {
+			return { ok: false, format: "html", error: `Studio HTML export failed: ${error instanceof Error ? error.message : String(error)}` };
+		}
+	};
+
 	const openStudioView = async (
 		trimmed: string,
 		ctx: ExtensionCommandContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-studio",
-  "version": "0.9.23",
+  "version": "0.9.24",
   "description": "Two-pane browser workspace for pi with prompt/response editing, annotations, critiques, active quiz, prompt/response history, live previews, and tmux-backed REPL/literate REPL workflows",
   "type": "module",
   "license": "MIT",