pi-studio 0.4.1 → 0.4.3

package/index.ts

@@ -2,8 +2,10 @@ import type { ExtensionAPI, ExtensionCommandContext, SessionEntry, Theme } from
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { readFileSync, statSync, 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 { dirname, isAbsolute, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { URL } from "node:url";
 import { WebSocketServer, WebSocket, type RawData } from "ws";
 
@@ -11,6 +13,7 @@ type Lens = "writing" | "code";
 type RequestedLens = Lens | "auto";
 type StudioRequestKind = "critique" | "annotation" | "direct";
 type StudioSourceKind = "file" | "last-response" | "blank";
+type TerminalActivityPhase = "idle" | "running" | "tool" | "responding";
 
 interface StudioServerState {
 	server: Server;
@@ -90,6 +93,11 @@ interface SendToEditorRequestMessage {
 	content: string;
 }
 
+interface GetFromEditorRequestMessage {
+	type: "get_from_editor_request";
+	requestId: string;
+}
+
 type IncomingStudioMessage =
 	| HelloMessage
 	| PingMessage
@@ -99,12 +107,26 @@ type IncomingStudioMessage =
 	| SendRunRequestMessage
 	| SaveAsRequestMessage
 	| SaveOverRequestMessage
-	| SendToEditorRequestMessage;
+	| SendToEditorRequestMessage
+	| GetFromEditorRequestMessage;
 
 const REQUEST_TIMEOUT_MS = 5 * 60 * 1000;
 const PREVIEW_RENDER_MAX_CHARS = 400_000;
+const PDF_EXPORT_MAX_CHARS = 400_000;
 const REQUEST_BODY_MAX_BYTES = 1_000_000;
 
+const PDF_PREAMBLE = `\\usepackage{titlesec}
+\\titleformat{\\section}{\\Large\\bfseries\\sffamily}{}{0pt}{}[\\vspace{2pt}\\titlerule]
+\\titleformat{\\subsection}{\\large\\bfseries\\sffamily}{}{0pt}{}
+\\titleformat{\\subsubsection}{\\normalsize\\bfseries\\sffamily}{}{0pt}{}
+\\titlespacing*{\\section}{0pt}{1.5ex plus 0.5ex minus 0.2ex}{1ex plus 0.2ex}
+\\titlespacing*{\\subsection}{0pt}{1.2ex plus 0.4ex minus 0.2ex}{0.6ex plus 0.1ex}
+\\usepackage{enumitem}
+\\setlist[itemize]{nosep, leftmargin=1.5em}
+\\setlist[enumerate]{nosep, leftmargin=1.5em}
+\\usepackage{parskip}
+`;
+
 type StudioThemeMode = "dark" | "light";
 
 interface StudioPalette {
@@ -793,6 +815,85 @@ async function renderStudioMarkdownWithPandoc(markdown: string, isLatex?: boolea
 	});
 }
 
+async function renderStudioPdfWithPandoc(markdown: string, isLatex?: boolean, resourcePath?: string): Promise<Buffer> {
+	const pandocCommand = process.env.PANDOC_PATH?.trim() || "pandoc";
+	const pdfEngine = process.env.PANDOC_PDF_ENGINE?.trim() || "xelatex";
+	const inputFormat = isLatex
+		? "latex"
+		: "gfm+tex_math_dollars+autolink_bare_uris+superscript+subscript-raw_html";
+	const normalizedMarkdown = isLatex ? markdown : normalizeObsidianImages(normalizeMathDelimiters(markdown));
+
+	const tempDir = join(tmpdir(), `pi-studio-pdf-${Date.now()}-${randomUUID()}`);
+	const preamblePath = join(tempDir, "_pdf_preamble.tex");
+	const outputPath = join(tempDir, "studio-export.pdf");
+
+	await mkdir(tempDir, { recursive: true });
+	await writeFile(preamblePath, PDF_PREAMBLE, "utf-8");
+
+	const args = [
+		"-f", inputFormat,
+		"-o", outputPath,
+		`--pdf-engine=${pdfEngine}`,
+		"-V", "geometry:margin=2.2cm",
+		"-V", "fontsize=11pt",
+		"-V", "linestretch=1.25",
+		"-V", "urlcolor=blue",
+		"-V", "linkcolor=blue",
+		"--include-in-header", preamblePath,
+	];
+	if (resourcePath) args.push(`--resource-path=${resourcePath}`);
+
+	try {
+		await new Promise<void>((resolve, reject) => {
+			const child = spawn(pandocCommand, args, { stdio: ["pipe", "pipe", "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") {
+					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(normalizedMarkdown);
+		});
+
+		return await readFile(outputPath);
+	} finally {
+		await rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+	}
+}
+
 function readRequestBody(req: IncomingMessage, maxBytes: number): Promise<string> {
 	return new Promise((resolve, reject) => {
 		const chunks: Buffer[] = [];
@@ -1133,9 +1234,146 @@ function parseIncomingMessage(data: RawData): IncomingStudioMessage | null {
 		};
 	}
 
+	if (msg.type === "get_from_editor_request" && typeof msg.requestId === "string") {
+		return {
+			type: "get_from_editor_request",
+			requestId: msg.requestId,
+		};
+	}
+
 	return null;
 }
 
+function normalizeActivityLabel(label: string): string | null {
+	const compact = String(label || "").replace(/\s+/g, " ").trim();
+	if (!compact) return null;
+	if (compact.length <= 96) return compact;
+	return `${compact.slice(0, 93).trimEnd()}…`;
+}
+
+function isGenericToolActivityLabel(label: string | null | undefined): boolean {
+	const normalized = String(label || "").trim().toLowerCase();
+	if (!normalized) return true;
+	return normalized.startsWith("running ")
+		|| normalized === "reading file"
+		|| normalized === "writing file"
+		|| normalized === "editing file";
+}
+
+function deriveBashActivityLabel(command: string): string | null {
+	const normalized = String(command || "").trim();
+	if (!normalized) return null;
+	const lower = normalized.toLowerCase();
+
+	const segments = lower
+		.split(/(?:&&|\|\||;|\n)+/g)
+		.map((segment) => segment.trim())
+		.filter((segment) => segment.length > 0);
+
+	let hasPwd = false;
+	let hasLsCurrent = false;
+	let hasLsParent = false;
+	let hasFind = false;
+	let hasFindCurrentListing = false;
+	let hasFindParentListing = false;
+
+	for (const segment of segments) {
+		if (/\bpwd\b/.test(segment)) hasPwd = true;
+
+		if (/\bls\b/.test(segment)) {
+			if (/\.\./.test(segment)) hasLsParent = true;
+			else hasLsCurrent = true;
+		}
+
+		if (/\bfind\b/.test(segment)) {
+			hasFind = true;
+			const pathMatch = segment.match(/\bfind\s+([^\s]+)/);
+			const pathToken = pathMatch ? pathMatch[1] : "";
+			const hasSelector = /-(?:name|iname|regex|path|ipath|newer|mtime|mmin|size|user|group)\b/.test(segment);
+			const listingLike = /-maxdepth\s+\d+\b/.test(segment) && !hasSelector;
+
+			if (listingLike) {
+				if (pathToken === ".." || pathToken === "../") {
+					hasFindParentListing = true;
+				} else if (pathToken === "." || pathToken === "./" || pathToken === "") {
+					hasFindCurrentListing = true;
+				}
+			}
+		}
+	}
+
+	const hasCurrentListing = hasLsCurrent || hasFindCurrentListing;
+	const hasParentListing = hasLsParent || hasFindParentListing;
+
+	if (hasCurrentListing && hasParentListing) {
+		return "Listing directory and parent directory files";
+	}
+	if (hasPwd && hasCurrentListing) {
+		return "Listing current directory files";
+	}
+	if (hasParentListing) {
+		return "Listing parent directory files";
+	}
+	if (hasCurrentListing || /\bls\b/.test(lower)) {
+		return "Listing directory files";
+	}
+	if (hasFind || /\bfind\b/.test(lower)) {
+		return "Searching files";
+	}
+	if (/\brg\b/.test(lower) || /\bgrep\b/.test(lower)) {
+		return "Searching text in files";
+	}
+	if (/\bcat\b/.test(lower) || /\bsed\b/.test(lower) || /\bawk\b/.test(lower)) {
+		return "Reading file content";
+	}
+	if (/\bgit\s+status\b/.test(lower)) {
+		return "Checking git status";
+	}
+	if (/\bgit\s+diff\b/.test(lower)) {
+		return "Reviewing git changes";
+	}
+	if (/\bgit\b/.test(lower)) {
+		return "Running git command";
+	}
+	if (/\bnpm\b/.test(lower)) {
+		return "Running npm command";
+	}
+	if (/\bpython3?\b/.test(lower)) {
+		return "Running Python command";
+	}
+	if (/\bnode\b/.test(lower)) {
+		return "Running Node.js command";
+	}
+	return "Running shell command";
+}
+
+function deriveToolActivityLabel(toolName: string, args: unknown): string | null {
+	const normalizedTool = String(toolName || "").trim().toLowerCase();
+	const payload = (args && typeof args === "object") ? (args as Record<string, unknown>) : {};
+
+	if (normalizedTool === "bash") {
+		const command = typeof payload.command === "string" ? payload.command : "";
+		return deriveBashActivityLabel(command);
+	}
+	if (normalizedTool === "read") {
+		const path = typeof payload.path === "string" ? payload.path : "";
+		return path ? `Reading ${basename(path)}` : "Reading file";
+	}
+	if (normalizedTool === "write") {
+		const path = typeof payload.path === "string" ? payload.path : "";
+		return path ? `Writing ${basename(path)}` : "Writing file";
+	}
+	if (normalizedTool === "edit") {
+		const path = typeof payload.path === "string" ? payload.path : "";
+		return path ? `Editing ${basename(path)}` : "Editing file";
+	}
+	if (normalizedTool === "find") return "Searching files";
+	if (normalizedTool === "grep") return "Searching text in files";
+	if (normalizedTool === "ls") return "Listing directory files";
+
+	return normalizeActivityLabel(`Running ${normalizedTool || "tool"}`);
+}
+
 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,
@@ -1148,6 +1386,50 @@ function buildStudioUrl(port: number, token: string): string {
 	return `http://127.0.0.1:${port}/?token=${encoded}`;
 }
 
+function formatModelLabel(model: { provider?: string; id?: string } | undefined): string {
+	const provider = typeof model?.provider === "string" ? model.provider.trim() : "";
+	const id = typeof model?.id === "string" ? model.id.trim() : "";
+	if (provider && id) return `${provider}/${id}`;
+	if (id) return id;
+	return "none";
+}
+
+function formatModelLabelWithThinking(modelLabel: string, thinkingLevel?: string): string {
+	const base = String(modelLabel || "").replace(/\s*\([^)]*\)\s*$/, "").trim() || "none";
+	if (base === "none") return "none";
+	const level = String(thinkingLevel ?? "").trim();
+	if (!level) return base;
+	return `${base} (${level})`;
+}
+
+function buildTerminalSessionLabel(cwd: string, sessionName?: string): string {
+	const cwdBase = basename(cwd || process.cwd() || "") || cwd || "~";
+	const termProgram = String(process.env.TERM_PROGRAM ?? "").trim();
+	const name = String(sessionName ?? "").trim();
+	const parts: string[] = [];
+	if (termProgram) parts.push(termProgram);
+	if (name) parts.push(name);
+	parts.push(cwdBase);
+	return parts.join(" · ");
+}
+
+function sanitizePdfFilename(input: string | undefined): string {
+	const fallback = "studio-preview.pdf";
+	const raw = String(input ?? "").trim();
+	if (!raw) return fallback;
+
+	const noPath = raw.split(/[\\/]/).pop() ?? raw;
+	const cleaned = noPath
+		.replace(/[\x00-\x1f\x7f]+/g, "")
+		.replace(/[<>:"|?*]+/g, "-")
+		.trim();
+	if (!cleaned) return fallback;
+
+	const ensuredExt = cleaned.toLowerCase().endsWith(".pdf") ? cleaned : `${cleaned}.pdf`;
+	if (ensuredExt.length <= 160) return ensuredExt;
+	return `${ensuredExt.slice(0, 156)}.pdf`;
+}
+
 function buildThemeCssVars(style: StudioThemeStyle): Record<string, string> {
 	const panelShadow =
 		style.mode === "light"
@@ -1214,11 +1496,18 @@ function buildThemeCssVars(style: StudioThemeStyle): Record<string, string> {
 	};
 }
 
-function buildStudioHtml(initialDocument: InitialStudioDocument | null, theme?: Theme): string {
+function buildStudioHtml(
+	initialDocument: InitialStudioDocument | null,
+	theme?: Theme,
+	initialModelLabel?: string,
+	initialTerminalLabel?: string,
+): string {
 	const initialText = escapeHtmlForInline(initialDocument?.text ?? "");
 	const initialSource = initialDocument?.source ?? "blank";
 	const initialLabel = escapeHtmlForInline(initialDocument?.label ?? "blank");
 	const initialPath = escapeHtmlForInline(initialDocument?.path ?? "");
+	const initialModel = escapeHtmlForInline(initialModelLabel ?? "none");
+	const initialTerminal = escapeHtmlForInline(initialTerminalLabel ?? "unknown");
 	const style = getStudioThemeStyle(theme);
 	const vars = buildThemeCssVars(style);
 	const mermaidConfig = {
@@ -1696,6 +1985,7 @@ ${cssVarsBlock}
     }
 
     .panel-scroll {
+      position: relative;
       min-height: 0;
       overflow: auto;
       padding: 12px;
@@ -1968,6 +2258,19 @@ ${cssVarsBlock}
       font-style: italic;
     }
 
+    .panel-scroll.preview-pending::after {
+      content: "Updating";
+      position: absolute;
+      top: 10px;
+      right: 12px;
+      color: var(--muted);
+      font-size: 10px;
+      line-height: 1.2;
+      letter-spacing: 0.01em;
+      pointer-events: none;
+      opacity: 0.64;
+    }
+
     .preview-error {
       color: var(--warn);
       margin-bottom: 0.75em;
@@ -2028,28 +2331,104 @@ ${cssVarsBlock}
       font-size: 12px;
       min-height: 32px;
       background: var(--panel);
-      display: flex;
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      grid-template-areas:
+        "status hint"
+        "meta hint";
+      column-gap: 12px;
+      row-gap: 3px;
+      align-items: start;
+    }
+
+    #statusLine {
+      grid-area: status;
+      display: inline-flex;
       align-items: center;
-      justify-content: space-between;
-      gap: 10px;
-      flex-wrap: wrap;
+      gap: 0;
+      min-width: 0;
+      justify-self: start;
+      text-align: left;
+    }
+
+    #statusLine.with-spinner {
+      gap: 6px;
+    }
+
+    #statusSpinner {
+      width: 0;
+      max-width: 0;
+      overflow: hidden;
+      opacity: 0;
+      text-align: center;
+      color: var(--accent);
+      font-family: var(--font-mono);
+      flex: 0 0 auto;
+      transition: opacity 120ms ease;
+    }
+
+    #statusLine.with-spinner #statusSpinner {
+      width: 1.1em;
+      max-width: 1.1em;
+      opacity: 1;
     }
 
     #status {
-      flex: 1 1 auto;
-      min-width: 240px;
+      min-width: 0;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      text-align: left;
+    }
+
+    .footer-meta {
+      grid-area: meta;
+      justify-self: start;
+      color: var(--muted);
+      font-size: 11px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      text-align: left;
+      max-width: 100%;
     }
 
     .shortcut-hint {
+      grid-area: hint;
+      justify-self: end;
+      align-self: center;
       color: var(--muted);
       font-size: 11px;
       white-space: nowrap;
+      text-align: right;
       font-style: normal;
+      opacity: 0.9;
     }
 
-    footer.error { color: var(--error); }
-    footer.warning { color: var(--warn); }
-    footer.success { color: var(--ok); }
+    #status.error { color: var(--error); }
+    #status.warning { color: var(--warn); }
+    #status.success { color: var(--ok); }
+
+    @media (max-width: 980px) {
+      footer {
+        grid-template-columns: 1fr;
+        grid-template-areas:
+          "status"
+          "meta"
+          "hint";
+      }
+
+      .footer-meta {
+        justify-self: start;
+        max-width: 100%;
+      }
+
+      .shortcut-hint {
+        justify-self: start;
+        text-align: left;
+        white-space: normal;
+      }
+    }
 
     @media (max-width: 1080px) {
       main {
@@ -2058,7 +2437,7 @@ ${cssVarsBlock}
     }
   </style>
 </head>
-<body data-initial-source="${initialSource}" data-initial-label="${initialLabel}" data-initial-path="${initialPath}">
+<body data-initial-source="${initialSource}" data-initial-label="${initialLabel}" data-initial-path="${initialPath}" data-model-label="${initialModel}" data-terminal-label="${initialTerminal}">
   <header>
     <h1><span class="app-logo" aria-hidden="true">π</span> Pi Studio <span class="app-subtitle">Editor & Response Workspace</span></h1>
     <div class="controls">
@@ -2089,7 +2468,7 @@ ${cssVarsBlock}
             <span id="syncBadge" class="source-badge sync-badge">No response loaded</span>
           </div>
           <div class="source-actions">
-            <button id="sendRunBtn" type="button" title="Send editor text directly to the model as-is.">Run editor text</button>
+            <button id="sendRunBtn" type="button" title="Send editor text directly to the model as-is. Shortcut: Cmd/Ctrl+Enter when editor pane is active.">Run editor text</button>
             <button id="insertHeaderBtn" type="button" title="Prepends/updates the annotated-reply header in the editor.">Insert annotation header</button>
             <select id="lensSelect" aria-label="Critique focus">
               <option value="auto" selected>Critique focus: Auto</option>
@@ -2098,6 +2477,7 @@ ${cssVarsBlock}
             </select>
             <button id="critiqueBtn" type="button">Critique editor text</button>
             <button id="sendEditorBtn" type="button">Send to pi editor</button>
+            <button id="getEditorBtn" type="button" title="Load the current terminal editor draft into Studio.">Load from pi editor</button>
             <button id="copyDraftBtn" type="button">Copy editor text</button>
             <select id="highlightSelect" aria-label="Editor syntax highlighting">
               <option value="off">Syntax highlight: Off</option>
@@ -2168,29 +2548,47 @@ ${cssVarsBlock}
           <button id="loadCritiqueNotesBtn" type="button" hidden>Load critique notes into editor</button>
           <button id="loadCritiqueFullBtn" type="button" hidden>Load full critique into editor</button>
           <button id="copyResponseBtn" type="button">Copy response text</button>
+          <button id="exportPdfBtn" type="button" title="Export the current right-pane preview as PDF via pandoc + xelatex.">Export right preview as PDF</button>
         </div>
       </div>
     </section>
   </main>
 
   <footer>
-    <span id="status">Booting studio…</span>
-    <span class="shortcut-hint">Focus pane: Cmd/Ctrl+Esc (or F10), Esc to exit</span>
+    <span id="statusLine"><span id="statusSpinner" aria-hidden="true"> </span><span id="status">Booting studio…</span></span>
+    <span id="footerMeta" class="footer-meta">Model: ${initialModel} · Terminal: ${initialTerminal}</span>
+    <span class="shortcut-hint">Focus pane: Cmd/Ctrl+Esc (or F10), Esc to exit · Run editor text: Cmd/Ctrl+Enter</span>
   </footer>
 
   <!-- Defer sanitizer script so studio can boot/connect even if CDN is slow or blocked. -->
   <script defer src="https://cdn.jsdelivr.net/npm/dompurify@3.2.6/dist/purify.min.js"></script>
   <script>
     (() => {
+      const statusLineEl = document.getElementById("statusLine");
       const statusEl = document.getElementById("status");
+      const statusSpinnerEl = document.getElementById("statusSpinner");
+      const footerMetaEl = document.getElementById("footerMeta");
+      const BRAILLE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+      let spinnerTimer = null;
+      let spinnerFrameIndex = 0;
       if (statusEl) {
-        statusEl.textContent = "WS: Connecting · Studio script starting…";
+        statusEl.textContent = "Connecting · Studio script starting…";
       }
 
       function hardFail(prefix, error) {
         const details = error && error.message ? error.message : String(error || "unknown error");
+        if (spinnerTimer) {
+          window.clearInterval(spinnerTimer);
+          spinnerTimer = null;
+        }
+        if (statusLineEl && statusLineEl.classList) {
+          statusLineEl.classList.remove("with-spinner");
+        }
+        if (statusSpinnerEl) {
+          statusSpinnerEl.textContent = "";
+        }
         if (statusEl) {
-          statusEl.textContent = "WS: Disconnected · " + prefix + ": " + details;
+          statusEl.textContent = "Disconnected · " + prefix + ": " + details;
           statusEl.className = "error";
         }
       }
@@ -2232,9 +2630,11 @@ ${cssVarsBlock}
       const loadCritiqueNotesBtn = document.getElementById("loadCritiqueNotesBtn");
       const loadCritiqueFullBtn = document.getElementById("loadCritiqueFullBtn");
       const copyResponseBtn = document.getElementById("copyResponseBtn");
+      const exportPdfBtn = document.getElementById("exportPdfBtn");
       const saveAsBtn = document.getElementById("saveAsBtn");
       const saveOverBtn = document.getElementById("saveOverBtn");
       const sendEditorBtn = document.getElementById("sendEditorBtn");
+      const getEditorBtn = document.getElementById("getEditorBtn");
       const sendRunBtn = document.getElementById("sendRunBtn");
       const copyDraftBtn = document.getElementById("copyDraftBtn");
       const highlightSelect = document.getElementById("highlightSelect");
@@ -2248,10 +2648,11 @@ ${cssVarsBlock}
 
       let ws = null;
       let wsState = "Connecting";
-      let statusMessage = "Studio script starting…";
+      let statusMessage = "Connecting · Studio script starting…";
       let statusLevel = "";
       let pendingRequestId = null;
       let pendingKind = null;
+      let stickyStudioKind = null;
       let initialDocumentApplied = false;
       let editorView = "markdown";
       let rightView = "preview";
@@ -2265,7 +2666,15 @@ ${cssVarsBlock}
       let latestResponseNormalized = "";
       let latestCritiqueNotes = "";
       let latestCritiqueNotesNormalized = "";
+      let agentBusyFromServer = false;
+      let terminalActivityPhase = "idle";
+      let terminalActivityToolName = "";
+      let terminalActivityLabel = "";
+      let lastSpecificToolLabel = "";
       let uiBusy = false;
+      let pdfExportInProgress = false;
+      let modelLabel = (document.body && document.body.dataset && document.body.dataset.modelLabel) || "none";
+      let terminalSessionLabel = (document.body && document.body.dataset && document.body.dataset.terminalLabel) || "unknown";
       let sourceState = {
         source: initialSourceState.source,
         label: initialSourceState.label,
@@ -2317,6 +2726,8 @@ ${cssVarsBlock}
       const RESPONSE_HIGHLIGHT_MAX_CHARS = 120_000;
       const RESPONSE_HIGHLIGHT_STORAGE_KEY = "piStudio.responseHighlightEnabled";
       const PREVIEW_INPUT_DEBOUNCE_MS = 0;
+      const PREVIEW_PENDING_BADGE_DELAY_MS = 220;
+      const previewPendingTimers = new WeakMap();
       let sourcePreviewRenderTimer = null;
       let sourcePreviewRenderNonce = 0;
       let responsePreviewRenderNonce = 0;
@@ -2333,25 +2744,234 @@ ${cssVarsBlock}
       let mermaidModulePromise = null;
       let mermaidInitialized = false;
 
+      const DEBUG_ENABLED = (() => {
+        try {
+          const query = new URLSearchParams(window.location.search || "");
+          const hash = new URLSearchParams((window.location.hash || "").replace(/^#/, ""));
+          const value = String(query.get("debug") || hash.get("debug") || "").trim().toLowerCase();
+          return value === "1" || value === "true" || value === "yes" || value === "on";
+        } catch {
+          return false;
+        }
+      })();
+      const DEBUG_LOG_MAX = 400;
+      const debugLog = [];
+
+      function debugTrace(eventName, payload) {
+        if (!DEBUG_ENABLED) return;
+        const entry = {
+          ts: Date.now(),
+          event: String(eventName || ""),
+          payload: payload || null,
+        };
+        debugLog.push(entry);
+        if (debugLog.length > DEBUG_LOG_MAX) debugLog.shift();
+        window.__piStudioDebugLog = debugLog.slice();
+        try {
+          console.debug("[pi-studio]", new Date(entry.ts).toISOString(), entry.event, entry.payload);
+        } catch {
+          // ignore console errors
+        }
+      }
+
+      function summarizeServerMessage(message) {
+        if (!message || typeof message !== "object") return { type: "invalid" };
+        const summary = {
+          type: typeof message.type === "string" ? message.type : "unknown",
+        };
+        if (typeof message.requestId === "string") summary.requestId = message.requestId;
+        if (typeof message.activeRequestId === "string") summary.activeRequestId = message.activeRequestId;
+        if (typeof message.activeRequestKind === "string") summary.activeRequestKind = message.activeRequestKind;
+        if (typeof message.kind === "string") summary.kind = message.kind;
+        if (typeof message.event === "string") summary.event = message.event;
+        if (typeof message.timestamp === "number") summary.timestamp = message.timestamp;
+        if (typeof message.busy === "boolean") summary.busy = message.busy;
+        if (typeof message.agentBusy === "boolean") summary.agentBusy = message.agentBusy;
+        if (typeof message.terminalPhase === "string") summary.terminalPhase = message.terminalPhase;
+        if (typeof message.terminalToolName === "string") summary.terminalToolName = message.terminalToolName;
+        if (typeof message.terminalActivityLabel === "string") summary.terminalActivityLabel = message.terminalActivityLabel;
+        if (typeof message.modelLabel === "string") summary.modelLabel = message.modelLabel;
+        if (typeof message.terminalSessionLabel === "string") summary.terminalSessionLabel = message.terminalSessionLabel;
+        if (typeof message.stopReason === "string") summary.stopReason = message.stopReason;
+        if (typeof message.markdown === "string") summary.markdownLength = message.markdown.length;
+        if (typeof message.label === "string") summary.label = message.label;
+        if (typeof message.details === "object" && message.details !== null) summary.details = message.details;
+        return summary;
+      }
+
       function getIdleStatus() {
-        return "Ready. Edit text, then run or critique (insert annotation header if needed).";
+        return "Edit, load, or annotate text, then run, save, send to pi editor, or critique.";
+      }
+
+      function normalizeTerminalPhase(phase) {
+        if (phase === "running" || phase === "tool" || phase === "responding") return phase;
+        return "idle";
+      }
+
+      function normalizeActivityLabel(label) {
+        if (typeof label !== "string") return "";
+        return label.replace(/\\s+/g, " ").trim();
+      }
+
+      function isGenericToolLabel(label) {
+        const normalized = normalizeActivityLabel(label).toLowerCase();
+        if (!normalized) return true;
+        return normalized.startsWith("running ")
+          || normalized === "reading file"
+          || normalized === "writing file"
+          || normalized === "editing file";
+      }
+
+      function withEllipsis(text) {
+        const value = String(text || "").trim();
+        if (!value) return "";
+        if (/[….!?]$/.test(value)) return value;
+        return value + "…";
+      }
+
+      function updateTerminalActivityState(phase, toolName, label) {
+        terminalActivityPhase = normalizeTerminalPhase(phase);
+        terminalActivityToolName = typeof toolName === "string" ? toolName.trim() : "";
+        terminalActivityLabel = normalizeActivityLabel(label);
+
+        if (terminalActivityPhase === "tool" && terminalActivityLabel && !isGenericToolLabel(terminalActivityLabel)) {
+          lastSpecificToolLabel = terminalActivityLabel;
+        }
+        if (terminalActivityPhase === "idle") {
+          lastSpecificToolLabel = "";
+        }
+
+        syncFooterSpinnerState();
+      }
+
+      function getTerminalBusyStatus() {
+        if (terminalActivityPhase === "tool") {
+          if (terminalActivityLabel) {
+            return "Terminal: " + withEllipsis(terminalActivityLabel);
+          }
+          return terminalActivityToolName
+            ? "Terminal: running tool: " + terminalActivityToolName + "…"
+            : "Terminal: running tool…";
+        }
+        if (terminalActivityPhase === "responding") {
+          if (lastSpecificToolLabel) {
+            return "Terminal: " + lastSpecificToolLabel + " (generating response)…";
+          }
+          return "Terminal: generating response…";
+        }
+        if (terminalActivityPhase === "running" && lastSpecificToolLabel) {
+          return "Terminal: " + withEllipsis(lastSpecificToolLabel);
+        }
+        return "Terminal: running…";
+      }
+
+      function getStudioActionLabel(kind) {
+        if (kind === "annotation") return "sending annotated reply";
+        if (kind === "critique") return "running critique";
+        if (kind === "direct") return "running editor text";
+        if (kind === "send_to_editor") return "sending to pi editor";
+        if (kind === "get_from_editor") return "loading from pi editor";
+        if (kind === "save_as" || kind === "save_over") return "saving editor text";
+        return "submitting request";
+      }
+
+      function getStudioBusyStatus(kind) {
+        const action = getStudioActionLabel(kind);
+        if (terminalActivityPhase === "tool") {
+          if (terminalActivityLabel) {
+            return "Studio: " + withEllipsis(terminalActivityLabel);
+          }
+          return terminalActivityToolName
+            ? "Studio: " + action + " (tool: " + terminalActivityToolName + ")…"
+            : "Studio: " + action + " (running tool)…";
+        }
+        if (terminalActivityPhase === "responding") {
+          if (lastSpecificToolLabel) {
+            return "Studio: " + lastSpecificToolLabel + " (generating response)…";
+          }
+          return "Studio: " + action + " (generating response)…";
+        }
+        if (terminalActivityPhase === "running" && lastSpecificToolLabel) {
+          return "Studio: " + withEllipsis(lastSpecificToolLabel);
+        }
+        return "Studio: " + action + "…";
+      }
+
+      function shouldAnimateFooterSpinner() {
+        return wsState !== "Disconnected" && (uiBusy || agentBusyFromServer || terminalActivityPhase !== "idle");
+      }
+
+      function updateFooterMeta() {
+        if (!footerMetaEl) return;
+        const modelText = modelLabel && modelLabel.trim() ? modelLabel.trim() : "none";
+        const terminalText = terminalSessionLabel && terminalSessionLabel.trim() ? terminalSessionLabel.trim() : "unknown";
+        footerMetaEl.textContent = "Model: " + modelText + " · Terminal: " + terminalText;
+      }
+
+      function stopFooterSpinner() {
+        if (spinnerTimer) {
+          window.clearInterval(spinnerTimer);
+          spinnerTimer = null;
+        }
+      }
+
+      function startFooterSpinner() {
+        if (spinnerTimer) return;
+        spinnerTimer = window.setInterval(() => {
+          spinnerFrameIndex = (spinnerFrameIndex + 1) % BRAILLE_SPINNER_FRAMES.length;
+          renderStatus();
+        }, 80);
+      }
+
+      function syncFooterSpinnerState() {
+        if (shouldAnimateFooterSpinner()) {
+          startFooterSpinner();
+        } else {
+          stopFooterSpinner();
+        }
       }
 
       function renderStatus() {
-        const prefix = "WS: " + wsState;
-        statusEl.textContent = prefix + " · " + statusMessage;
+        statusEl.textContent = statusMessage;
         statusEl.className = statusLevel || "";
+
+        const spinnerActive = shouldAnimateFooterSpinner();
+        if (statusLineEl && statusLineEl.classList) {
+          statusLineEl.classList.toggle("with-spinner", spinnerActive);
+        }
+        if (statusSpinnerEl) {
+          statusSpinnerEl.textContent = spinnerActive
+            ? (BRAILLE_SPINNER_FRAMES[spinnerFrameIndex % BRAILLE_SPINNER_FRAMES.length] || "")
+            : "";
+        }
+
+        updateFooterMeta();
       }
 
       function setWsState(nextState) {
         wsState = nextState || "Disconnected";
+        syncFooterSpinnerState();
         renderStatus();
       }
 
       function setStatus(message, level) {
         statusMessage = message;
         statusLevel = level || "";
+        syncFooterSpinnerState();
         renderStatus();
+        debugTrace("status", {
+          wsState,
+          message: statusMessage,
+          level: statusLevel,
+          pendingRequestId,
+          pendingKind,
+          uiBusy,
+          agentBusyFromServer,
+          terminalPhase: terminalActivityPhase,
+          terminalToolName: terminalActivityToolName,
+          terminalActivityLabel,
+          lastSpecificToolLabel,
+        });
       }
 
       renderStatus();
@@ -2594,6 +3214,48 @@ ${cssVarsBlock}
         targetEl.appendChild(el);
       }
 
+      function hasMeaningfulPreviewContent(targetEl) {
+        if (!targetEl || typeof targetEl.querySelector !== "function") return false;
+        if (targetEl.querySelector(".preview-loading")) return false;
+        const text = typeof targetEl.textContent === "string" ? targetEl.textContent.trim() : "";
+        return text.length > 0;
+      }
+
+      function beginPreviewRender(targetEl) {
+        if (!targetEl || !targetEl.classList) return;
+
+        const pendingTimer = previewPendingTimers.get(targetEl);
+        if (pendingTimer !== undefined) {
+          window.clearTimeout(pendingTimer);
+          previewPendingTimers.delete(targetEl);
+        }
+
+        if (hasMeaningfulPreviewContent(targetEl)) {
+          targetEl.classList.remove("preview-pending");
+          const timerId = window.setTimeout(() => {
+            previewPendingTimers.delete(targetEl);
+            if (!targetEl || !targetEl.classList) return;
+            if (!hasMeaningfulPreviewContent(targetEl)) return;
+            targetEl.classList.add("preview-pending");
+          }, PREVIEW_PENDING_BADGE_DELAY_MS);
+          previewPendingTimers.set(targetEl, timerId);
+          return;
+        }
+
+        targetEl.classList.remove("preview-pending");
+        targetEl.innerHTML = "<div class='preview-loading'>Rendering preview…</div>";
+      }
+
+      function finishPreviewRender(targetEl) {
+        if (!targetEl || !targetEl.classList) return;
+        const pendingTimer = previewPendingTimers.get(targetEl);
+        if (pendingTimer !== undefined) {
+          window.clearTimeout(pendingTimer);
+          previewPendingTimers.delete(targetEl);
+        }
+        targetEl.classList.remove("preview-pending");
+      }
+
       async function getMermaidApi() {
         if (mermaidModulePromise) {
           return mermaidModulePromise;
@@ -2729,6 +3391,126 @@ ${cssVarsBlock}
         return payload.html;
       }
 
+      function parseContentDispositionFilename(headerValue) {
+        if (!headerValue || typeof headerValue !== "string") return "";
+
+        const utfMatch = headerValue.match(/filename\\*=UTF-8''([^;]+)/i);
+        if (utfMatch && utfMatch[1]) {
+          try {
+            return decodeURIComponent(utfMatch[1].trim());
+          } catch {
+            return utfMatch[1].trim();
+          }
+        }
+
+        const quotedMatch = headerValue.match(/filename="([^"]+)"/i);
+        if (quotedMatch && quotedMatch[1]) return quotedMatch[1].trim();
+
+        const plainMatch = headerValue.match(/filename=([^;]+)/i);
+        if (plainMatch && plainMatch[1]) return plainMatch[1].trim();
+
+        return "";
+      }
+
+      async function exportRightPanePdf() {
+        if (uiBusy || pdfExportInProgress) {
+          setStatus("Studio is busy.", "warning");
+          return;
+        }
+
+        const token = getToken();
+        if (!token) {
+          setStatus("Missing Studio token in URL. Re-run /studio.", "error");
+          return;
+        }
+
+        const rightPaneShowsPreview = rightView === "preview" || rightView === "editor-preview";
+        if (!rightPaneShowsPreview) {
+          setStatus("Switch right pane to Response (Preview) or Editor (Preview) to export PDF.", "warning");
+          return;
+        }
+
+        const markdown = rightView === "editor-preview" ? sourceTextEl.value : latestResponseMarkdown;
+        if (!markdown || !markdown.trim()) {
+          setStatus("Nothing to export yet.", "warning");
+          return;
+        }
+
+        const sourcePath = sourceState.path || "";
+        const resourceDir = (!sourceState.path && resourceDirInput) ? resourceDirInput.value.trim() : "";
+        const isLatex = /\\\\documentclass\\b|\\\\begin\\{document\\}/.test(markdown);
+        let filenameHint = rightView === "editor-preview" ? "studio-editor-preview.pdf" : "studio-response-preview.pdf";
+        if (sourceState.path) {
+          const baseName = sourceState.path.split(/[\\\\/]/).pop() || "studio";
+          const stem = baseName.replace(/\\.[^.]+$/, "") || "studio";
+          filenameHint = stem + "-preview.pdf";
+        }
+
+        pdfExportInProgress = true;
+        updateResultActionButtons();
+        setStatus("Exporting PDF…", "warning");
+
+        try {
+          const response = await fetch("/export-pdf?token=" + encodeURIComponent(token), {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              markdown: String(markdown || ""),
+              sourcePath: sourcePath,
+              resourceDir: resourceDir,
+              isLatex: isLatex,
+              filenameHint: filenameHint,
+            }),
+          });
+
+          if (!response.ok) {
+            const contentType = String(response.headers.get("content-type") || "").toLowerCase();
+            let message = "PDF export failed with HTTP " + response.status + ".";
+            if (contentType.includes("application/json")) {
+              const payload = await response.json().catch(() => null);
+              if (payload && typeof payload.error === "string") {
+                message = payload.error;
+              }
+            } else {
+              const text = await response.text().catch(() => "");
+              if (text && text.trim()) {
+                message = text.trim();
+              }
+            }
+            throw new Error(message);
+          }
+
+          const blob = await response.blob();
+          const headerFilename = parseContentDispositionFilename(response.headers.get("content-disposition"));
+          let downloadName = headerFilename || filenameHint || "studio-preview.pdf";
+          if (!/\\.pdf$/i.test(downloadName)) {
+            downloadName += ".pdf";
+          }
+
+          const blobUrl = URL.createObjectURL(blob);
+          const link = document.createElement("a");
+          link.href = blobUrl;
+          link.download = downloadName;
+          link.rel = "noopener";
+          document.body.appendChild(link);
+          link.click();
+          link.remove();
+          window.setTimeout(() => {
+            URL.revokeObjectURL(blobUrl);
+          }, 1800);
+
+          setStatus("Exported PDF: " + downloadName, "success");
+        } catch (error) {
+          const detail = error && error.message ? error.message : String(error || "unknown error");
+          setStatus("PDF export failed: " + detail, "error");
+        } finally {
+          pdfExportInProgress = false;
+          updateResultActionButtons();
+        }
+      }
+
       async function applyRenderedMarkdown(targetEl, markdown, pane, nonce) {
         try {
           const renderedHtml = await renderMarkdownWithPandoc(markdown);
@@ -2739,6 +3521,7 @@ ${cssVarsBlock}
             if (nonce !== responsePreviewRenderNonce || (rightView !== "preview" && rightView !== "editor-preview")) return;
           }
 
+          finishPreviewRender(targetEl);
           targetEl.innerHTML = sanitizeRenderedHtml(renderedHtml, markdown);
           await renderMermaidInElement(targetEl);
 
@@ -2758,6 +3541,7 @@ ${cssVarsBlock}
           }
 
           const detail = error && error.message ? error.message : String(error || "unknown error");
+          finishPreviewRender(targetEl);
           targetEl.innerHTML = buildPreviewErrorHtml("Preview renderer unavailable (" + detail + "). Showing plain markdown.", markdown);
         }
       }
@@ -2766,11 +3550,12 @@ ${cssVarsBlock}
         if (editorView !== "preview") return;
         const text = sourceTextEl.value || "";
         if (editorLanguage && editorLanguage !== "markdown" && editorLanguage !== "latex") {
+          finishPreviewRender(sourcePreviewEl);
           sourcePreviewEl.innerHTML = "<div class='response-markdown-highlight' style='white-space:pre;font-family:var(--font-mono);font-size:13px;line-height:1.5;padding:16px;overflow:auto;'>" + highlightCode(text, editorLanguage) + "</div>";
           return;
         }
         const nonce = ++sourcePreviewRenderNonce;
-        sourcePreviewEl.innerHTML = "<div class='preview-loading'>Rendering preview…</div>";
+        beginPreviewRender(sourcePreviewEl);
         void applyRenderedMarkdown(sourcePreviewEl, text, "source", nonce);
       }
 
@@ -2825,34 +3610,38 @@ ${cssVarsBlock}
         if (rightView === "editor-preview") {
           const editorText = sourceTextEl.value || "";
           if (!editorText.trim()) {
+            finishPreviewRender(critiqueViewEl);
             critiqueViewEl.innerHTML = "<pre class='plain-markdown'>Editor is empty.</pre>";
             return;
           }
           if (editorLanguage && editorLanguage !== "markdown" && editorLanguage !== "latex") {
+            finishPreviewRender(critiqueViewEl);
             critiqueViewEl.innerHTML = "<div class='response-markdown-highlight' style='white-space:pre;font-family:var(--font-mono);font-size:13px;line-height:1.5;padding:16px;overflow:auto;'>" + highlightCode(editorText, editorLanguage) + "</div>";
             return;
           }
           const nonce = ++responsePreviewRenderNonce;
-          critiqueViewEl.innerHTML = "<div class='preview-loading'>Rendering preview…</div>";
+          beginPreviewRender(critiqueViewEl);
           void applyRenderedMarkdown(critiqueViewEl, editorText, "response", nonce);
           return;
         }
 
         const markdown = latestResponseMarkdown;
         if (!markdown || !markdown.trim()) {
+          finishPreviewRender(critiqueViewEl);
           critiqueViewEl.innerHTML = "<pre class='plain-markdown'>No response yet. Run editor text or critique editor text.</pre>";
           return;
         }
 
         if (rightView === "preview") {
           const nonce = ++responsePreviewRenderNonce;
-          critiqueViewEl.innerHTML = "<div class='preview-loading'>Rendering preview…</div>";
+          beginPreviewRender(critiqueViewEl);
           void applyRenderedMarkdown(critiqueViewEl, markdown, "response", nonce);
           return;
         }
 
         if (responseHighlightEnabled) {
           if (markdown.length > RESPONSE_HIGHLIGHT_MAX_CHARS) {
+            finishPreviewRender(critiqueViewEl);
             critiqueViewEl.innerHTML = buildPreviewErrorHtml(
               "Response is too large for markdown highlighting. Showing plain markdown.",
               markdown,
@@ -2860,10 +3649,12 @@ ${cssVarsBlock}
             return;
           }
 
+          finishPreviewRender(critiqueViewEl);
           critiqueViewEl.innerHTML = "<div class='response-markdown-highlight'>" + highlightMarkdown(markdown) + "</div>";
           return;
         }
 
+        finishPreviewRender(critiqueViewEl);
         critiqueViewEl.innerHTML = buildPlainMarkdownHtml(markdown);
       }
 
@@ -2893,6 +3684,20 @@ ${cssVarsBlock}
 
         copyResponseBtn.disabled = uiBusy || !hasResponse;
 
+        const rightPaneShowsPreview = rightView === "preview" || rightView === "editor-preview";
+        const exportText = rightView === "editor-preview" ? sourceTextEl.value : latestResponseMarkdown;
+        const canExportPdf = rightPaneShowsPreview && Boolean(String(exportText || "").trim());
+        if (exportPdfBtn) {
+          exportPdfBtn.disabled = uiBusy || pdfExportInProgress || !canExportPdf;
+          if (rightView === "markdown") {
+            exportPdfBtn.title = "Switch right pane to Response (Preview) or Editor (Preview) to export PDF.";
+          } else if (!canExportPdf) {
+            exportPdfBtn.title = "Nothing to export yet.";
+          } else {
+            exportPdfBtn.title = "Export the current right-pane preview as PDF via pandoc + xelatex.";
+          }
+        }
+
         pullLatestBtn.disabled = uiBusy || followLatest;
         pullLatestBtn.textContent = queuedLatestResponse ? "Get latest response *" : "Get latest response";
 
@@ -2936,6 +3741,7 @@ ${cssVarsBlock}
         saveAsBtn.disabled = uiBusy;
         saveOverBtn.disabled = uiBusy || !canSaveOver;
         sendEditorBtn.disabled = uiBusy;
+        if (getEditorBtn) getEditorBtn.disabled = uiBusy;
         sendRunBtn.disabled = uiBusy;
         copyDraftBtn.disabled = uiBusy;
         if (highlightSelect) highlightSelect.disabled = uiBusy;
@@ -2953,6 +3759,8 @@ ${cssVarsBlock}
 
       function setBusy(busy) {
         uiBusy = Boolean(busy);
+        syncFooterSpinnerState();
+        renderStatus();
         syncActionButtons();
       }
 
@@ -2981,6 +3789,10 @@ ${cssVarsBlock}
           sourcePreviewRenderTimer = null;
         }
 
+        if (!showPreview) {
+          finishPreviewRender(sourcePreviewEl);
+        }
+
         if (showPreview) {
           renderSourcePreview();
         }
@@ -3665,14 +4477,37 @@ ${cssVarsBlock}
       function handleServerMessage(message) {
         if (!message || typeof message !== "object") return;
 
+        debugTrace("server_message", summarizeServerMessage(message));
+
+        if (message.type === "debug_event") {
+          debugTrace("server_debug_event", summarizeServerMessage(message));
+          return;
+        }
+
         if (message.type === "hello_ack") {
           const busy = Boolean(message.busy);
+          agentBusyFromServer = Boolean(message.agentBusy);
+          updateTerminalActivityState(message.terminalPhase, message.terminalToolName, message.terminalActivityLabel);
+          if (typeof message.modelLabel === "string") {
+            modelLabel = message.modelLabel;
+          }
+          if (typeof message.terminalSessionLabel === "string") {
+            terminalSessionLabel = message.terminalSessionLabel;
+          }
+          updateFooterMeta();
           setBusy(busy);
           setWsState(busy ? "Submitting" : "Ready");
-          if (message.activeRequestId) {
-            pendingRequestId = String(message.activeRequestId);
-            pendingKind = "unknown";
-            setStatus("Request in progress…", "warning");
+          if (typeof message.activeRequestId === "string" && message.activeRequestId.length > 0) {
+            pendingRequestId = message.activeRequestId;
+            if (typeof message.activeRequestKind === "string" && message.activeRequestKind.length > 0) {
+              pendingKind = message.activeRequestKind;
+            } else if (!pendingKind) {
+              pendingKind = "unknown";
+            }
+            stickyStudioKind = pendingKind;
+          } else {
+            pendingRequestId = null;
+            pendingKind = null;
           }
 
           let loadedInitialDocument = false;
@@ -3705,7 +4540,26 @@ ${cssVarsBlock}
             handleIncomingResponse(lastMarkdown, lastResponseKind, message.lastResponse.timestamp);
           }
 
-          if (!busy && !loadedInitialDocument) {
+          if (pendingRequestId) {
+            if (busy) {
+              setStatus(getStudioBusyStatus(pendingKind), "warning");
+            }
+            return;
+          }
+
+          if (busy) {
+            if (agentBusyFromServer && stickyStudioKind) {
+              setStatus(getStudioBusyStatus(stickyStudioKind), "warning");
+            } else if (agentBusyFromServer) {
+              setStatus(getTerminalBusyStatus(), "warning");
+            } else {
+              setStatus("Studio is busy.", "warning");
+            }
+            return;
+          }
+
+          stickyStudioKind = null;
+          if (!loadedInitialDocument) {
             refreshResponseUi();
             setStatus(getIdleStatus());
           }
@@ -3715,17 +4569,10 @@ ${cssVarsBlock}
         if (message.type === "request_started") {
           pendingRequestId = typeof message.requestId === "string" ? message.requestId : pendingRequestId;
           pendingKind = typeof message.kind === "string" ? message.kind : "unknown";
+          stickyStudioKind = pendingKind;
           setBusy(true);
           setWsState("Submitting");
-          if (pendingKind === "annotation") {
-            setStatus("Sending annotated reply…", "warning");
-          } else if (pendingKind === "critique") {
-            setStatus("Running critique…", "warning");
-          } else if (pendingKind === "direct") {
-            setStatus("Running editor text…", "warning");
-          } else {
-            setStatus("Submitting…", "warning");
-          }
+          setStatus(getStudioBusyStatus(pendingKind), "warning");
           return;
         }
 
@@ -3739,6 +4586,7 @@ ${cssVarsBlock}
               ? message.kind
               : (pendingKind === "critique" ? "critique" : "annotation");
 
+          stickyStudioKind = responseKind;
           pendingRequestId = null;
           pendingKind = null;
           setBusy(false);
@@ -3810,13 +4658,78 @@ ${cssVarsBlock}
           return;
         }
 
+        if (message.type === "editor_snapshot") {
+          if (typeof message.requestId === "string" && pendingRequestId && message.requestId !== pendingRequestId) {
+            return;
+          }
+          if (typeof message.requestId === "string" && pendingRequestId === message.requestId) {
+            pendingRequestId = null;
+            pendingKind = null;
+          }
+
+          const content = typeof message.content === "string" ? message.content : "";
+          sourceTextEl.value = content;
+          renderSourcePreview();
+          setSourceState({ source: "pi-editor", label: "pi editor draft", path: null });
+          setBusy(false);
+          setWsState("Ready");
+          setStatus(
+            content.trim()
+              ? "Loaded draft from pi editor."
+              : "pi editor is empty. Loaded blank text.",
+            content.trim() ? "success" : "warning",
+          );
+          return;
+        }
+
         if (message.type === "studio_state") {
           const busy = Boolean(message.busy);
+          agentBusyFromServer = Boolean(message.agentBusy);
+          updateTerminalActivityState(message.terminalPhase, message.terminalToolName, message.terminalActivityLabel);
+          if (typeof message.modelLabel === "string") {
+            modelLabel = message.modelLabel;
+          }
+          if (typeof message.terminalSessionLabel === "string") {
+            terminalSessionLabel = message.terminalSessionLabel;
+          }
+          updateFooterMeta();
+
+          if (typeof message.activeRequestId === "string" && message.activeRequestId.length > 0) {
+            pendingRequestId = message.activeRequestId;
+            if (typeof message.activeRequestKind === "string" && message.activeRequestKind.length > 0) {
+              pendingKind = message.activeRequestKind;
+            } else if (!pendingKind) {
+              pendingKind = "unknown";
+            }
+            stickyStudioKind = pendingKind;
+          } else {
+            pendingRequestId = null;
+            pendingKind = null;
+          }
+
           setBusy(busy);
           setWsState(busy ? "Submitting" : "Ready");
-          if (!busy && !pendingRequestId) {
-            setStatus(getIdleStatus());
+
+          if (pendingRequestId) {
+            if (busy) {
+              setStatus(getStudioBusyStatus(pendingKind), "warning");
+            }
+            return;
+          }
+
+          if (busy) {
+            if (agentBusyFromServer && stickyStudioKind) {
+              setStatus(getStudioBusyStatus(stickyStudioKind), "warning");
+            } else if (agentBusyFromServer) {
+              setStatus(getTerminalBusyStatus(), "warning");
+            } else {
+              setStatus("Studio is busy.", "warning");
+            }
+            return;
           }
+
+          stickyStudioKind = null;
+          setStatus(getIdleStatus());
           return;
         }
 
@@ -3825,6 +4738,7 @@ ${cssVarsBlock}
             pendingRequestId = null;
             pendingKind = null;
           }
+          stickyStudioKind = null;
           setBusy(false);
           setWsState("Ready");
           setStatus(typeof message.message === "string" ? message.message : "Studio is busy.", "warning");
@@ -3836,6 +4750,7 @@ ${cssVarsBlock}
             pendingRequestId = null;
             pendingKind = null;
           }
+          stickyStudioKind = null;
           setBusy(false);
           setWsState("Ready");
           setStatus(typeof message.message === "string" ? message.message : "Request failed.", "error");
@@ -3870,7 +4785,7 @@ ${cssVarsBlock}
         }
 
         const wsProtocol = window.location.protocol === "https:" ? "wss" : "ws";
-        const wsUrl = wsProtocol + "://" + window.location.host + "/ws?token=" + encodeURIComponent(token);
+        const wsUrl = wsProtocol + "://" + window.location.host + "/ws?token=" + encodeURIComponent(token) + (DEBUG_ENABLED ? "&debug=1" : "");
 
         setWsState("Connecting");
         setStatus("Connecting to Studio server…");
@@ -3927,8 +4842,10 @@ ${cssVarsBlock}
         const requestId = makeRequestId();
         pendingRequestId = requestId;
         pendingKind = kind;
+        stickyStudioKind = kind;
         setBusy(true);
         setWsState("Submitting");
+        setStatus(getStudioBusyStatus(kind), "warning");
         return requestId;
       }
 
@@ -4006,6 +4923,9 @@ ${cssVarsBlock}
       }
 
       window.addEventListener("keydown", handlePaneShortcut);
+      window.addEventListener("beforeunload", () => {
+        stopFooterSpinner();
+      });
 
       editorViewSelect.addEventListener("change", () => {
         setEditorView(editorViewSelect.value);
@@ -4151,6 +5071,12 @@ ${cssVarsBlock}
         }
       });
 
+      if (exportPdfBtn) {
+        exportPdfBtn.addEventListener("click", () => {
+          void exportRightPanePdf();
+        });
+      }
+
       saveAsBtn.addEventListener("click", () => {
         const content = sourceTextEl.value;
         if (!content.trim()) {
@@ -4233,6 +5159,24 @@ ${cssVarsBlock}
         }
       });
 
+      if (getEditorBtn) {
+        getEditorBtn.addEventListener("click", () => {
+          const requestId = beginUiAction("get_from_editor");
+          if (!requestId) return;
+
+          const sent = sendMessage({
+            type: "get_from_editor_request",
+            requestId,
+          });
+
+          if (!sent) {
+            pendingRequestId = null;
+            pendingKind = null;
+            setBusy(false);
+          }
+        });
+      }
+
       sendRunBtn.addEventListener("click", () => {
         const content = sourceTextEl.value;
         if (!content.trim()) {
@@ -4397,9 +5341,41 @@ export default function (pi: ExtensionAPI) {
 	let lastCommandCtx: ExtensionCommandContext | null = null;
 	let lastThemeVarsJson = "";
 	let agentBusy = false;
+	let terminalActivityPhase: TerminalActivityPhase = "idle";
+	let terminalActivityToolName: string | null = null;
+	let terminalActivityLabel: string | null = null;
+	let lastSpecificToolActivityLabel: string | null = null;
+	let currentModelLabel = "none";
+	let terminalSessionLabel = buildTerminalSessionLabel(studioCwd);
 
 	const isStudioBusy = () => agentBusy || activeRequest !== null;
 
+	const getSessionNameSafe = (): string | undefined => {
+		try {
+			return pi.getSessionName();
+		} catch {
+			return undefined;
+		}
+	};
+
+	const getThinkingLevelSafe = (): string | undefined => {
+		try {
+			return pi.getThinkingLevel();
+		} catch {
+			return undefined;
+		}
+	};
+
+	const refreshRuntimeMetadata = (ctx?: { cwd?: string; model?: { provider?: string; id?: string } | undefined }) => {
+		if (ctx?.cwd) {
+			studioCwd = ctx.cwd;
+		}
+		const model = ctx?.model ?? lastCommandCtx?.model;
+		const baseModelLabel = formatModelLabel(model);
+		currentModelLabel = formatModelLabelWithThinking(baseModelLabel, getThinkingLevelSafe());
+		terminalSessionLabel = buildTerminalSessionLabel(studioCwd, getSessionNameSafe());
+	};
+
 	const notifyStudio = (message: string, level: "info" | "warning" | "error" = "info") => {
 		if (!lastCommandCtx) return;
 		lastCommandCtx.ui.notify(message, level);
@@ -4427,18 +5403,98 @@ export default function (pi: ExtensionAPI) {
 		}
 	};
 
+	const emitDebugEvent = (event: string, details?: Record<string, unknown>) => {
+		broadcast({
+			type: "debug_event",
+			event,
+			timestamp: Date.now(),
+			details: details ?? null,
+		});
+	};
+
+	const setTerminalActivity = (phase: TerminalActivityPhase, toolName?: string | null, label?: string | null) => {
+		const nextPhase: TerminalActivityPhase =
+			phase === "running" || phase === "tool" || phase === "responding"
+				? phase
+				: "idle";
+		const nextToolName = nextPhase === "tool" ? (toolName?.trim() || null) : null;
+		const baseLabel = nextPhase === "tool" ? normalizeActivityLabel(label || "") : null;
+		let nextLabel: string | null = null;
+
+		if (nextPhase === "tool") {
+			if (baseLabel && !isGenericToolActivityLabel(baseLabel)) {
+				if (
+					lastSpecificToolActivityLabel
+					&& lastSpecificToolActivityLabel !== baseLabel
+					&& !isGenericToolActivityLabel(lastSpecificToolActivityLabel)
+				) {
+					nextLabel = normalizeActivityLabel(`${lastSpecificToolActivityLabel} → ${baseLabel}`);
+				} else {
+					nextLabel = baseLabel;
+				}
+				lastSpecificToolActivityLabel = baseLabel;
+			} else {
+				nextLabel = baseLabel;
+			}
+		} else {
+			nextLabel = null;
+			if (nextPhase === "idle") {
+				lastSpecificToolActivityLabel = null;
+			}
+		}
+
+		if (
+			terminalActivityPhase === nextPhase
+			&& terminalActivityToolName === nextToolName
+			&& terminalActivityLabel === nextLabel
+		) {
+			return;
+		}
+		terminalActivityPhase = nextPhase;
+		terminalActivityToolName = nextToolName;
+		terminalActivityLabel = nextLabel;
+		emitDebugEvent("terminal_activity", {
+			phase: terminalActivityPhase,
+			toolName: terminalActivityToolName,
+			label: terminalActivityLabel,
+			baseLabel,
+			lastSpecificToolActivityLabel,
+			activeRequestId: activeRequest?.id ?? null,
+			activeRequestKind: activeRequest?.kind ?? null,
+			agentBusy,
+		});
+		broadcastState();
+	};
+
 	const broadcastState = () => {
+		terminalSessionLabel = buildTerminalSessionLabel(studioCwd, getSessionNameSafe());
+		currentModelLabel = formatModelLabelWithThinking(currentModelLabel, getThinkingLevelSafe());
 		broadcast({
 			type: "studio_state",
 			busy: isStudioBusy(),
+			agentBusy,
+			terminalPhase: terminalActivityPhase,
+			terminalToolName: terminalActivityToolName,
+			terminalActivityLabel,
+			modelLabel: currentModelLabel,
+			terminalSessionLabel,
 			activeRequestId: activeRequest?.id ?? null,
+			activeRequestKind: activeRequest?.kind ?? null,
 		});
 	};
 
 	const clearActiveRequest = (options?: { notify?: string; level?: "info" | "warning" | "error" }) => {
 		if (!activeRequest) return;
+		const completedRequestId = activeRequest.id;
+		const completedKind = activeRequest.kind;
 		clearTimeout(activeRequest.timer);
 		activeRequest = null;
+		emitDebugEvent("clear_active_request", {
+			requestId: completedRequestId,
+			kind: completedKind,
+			notify: options?.notify ?? null,
+			agentBusy,
+		});
 		broadcastState();
 		if (options?.notify) {
 			broadcast({ type: "info", message: options.notify, level: options.level ?? "info" });
@@ -4446,6 +5502,12 @@ export default function (pi: ExtensionAPI) {
 	};
 
 	const beginRequest = (requestId: string, kind: StudioRequestKind): boolean => {
+		emitDebugEvent("begin_request_attempt", {
+			requestId,
+			kind,
+			hasActiveRequest: Boolean(activeRequest),
+			agentBusy,
+		});
 		if (activeRequest) {
 			broadcast({ type: "busy", requestId, message: "A studio request is already in progress." });
 			return false;
@@ -4457,6 +5519,7 @@ export default function (pi: ExtensionAPI) {
 
 		const timer = setTimeout(() => {
 			if (!activeRequest || activeRequest.id !== requestId) return;
+			emitDebugEvent("request_timeout", { requestId, kind });
 			broadcast({ type: "error", requestId, message: "Studio request timed out. Please try again." });
 			clearActiveRequest();
 		}, REQUEST_TIMEOUT_MS);
@@ -4468,6 +5531,7 @@ export default function (pi: ExtensionAPI) {
 			timer,
 		};
 
+		emitDebugEvent("begin_request", { requestId, kind });
 		broadcast({ type: "request_started", requestId, kind });
 		broadcastState();
 		return true;
@@ -4491,11 +5555,26 @@ export default function (pi: ExtensionAPI) {
 			return;
 		}
 
+		emitDebugEvent("studio_message", {
+			type: msg.type,
+			requestId: "requestId" in msg ? msg.requestId : null,
+			activeRequestId: activeRequest?.id ?? null,
+			activeRequestKind: activeRequest?.kind ?? null,
+			agentBusy,
+		});
+
 		if (msg.type === "hello") {
 			sendToClient(client, {
 				type: "hello_ack",
 				busy: isStudioBusy(),
+				agentBusy,
+				terminalPhase: terminalActivityPhase,
+				terminalToolName: terminalActivityToolName,
+				terminalActivityLabel,
+				modelLabel: currentModelLabel,
+				terminalSessionLabel,
 				activeRequestId: activeRequest?.id ?? null,
+				activeRequestKind: activeRequest?.kind ?? null,
 				lastResponse: lastStudioResponse,
 				initialDocument: initialStudioDocument,
 			});
@@ -4727,6 +5806,41 @@ export default function (pi: ExtensionAPI) {
 			}
 			return;
 		}
+
+		if (msg.type === "get_from_editor_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;
+			}
+			if (!lastCommandCtx || !lastCommandCtx.hasUI) {
+				sendToClient(client, {
+					type: "error",
+					requestId: msg.requestId,
+					message: "No interactive pi editor context is available.",
+				});
+				return;
+			}
+
+			try {
+				const content = lastCommandCtx.ui.getEditorText();
+				sendToClient(client, {
+					type: "editor_snapshot",
+					requestId: msg.requestId,
+					content,
+				});
+			} catch (error) {
+				sendToClient(client, {
+					type: "error",
+					requestId: msg.requestId,
+					message: `Failed to read pi editor text: ${error instanceof Error ? error.message : String(error)}`,
+				});
+			}
+			return;
+		}
 	};
 
 	const handleRenderPreviewRequest = async (req: IncomingMessage, res: ServerResponse) => {
@@ -4785,6 +5899,84 @@ export default function (pi: ExtensionAPI) {
 		}
 	};
 
+	const handleExportPdfRequest = async (req: IncomingMessage, res: ServerResponse) => {
+		let rawBody = "";
+		try {
+			rawBody = await readRequestBody(req, REQUEST_BODY_MAX_BYTES);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const status = message.includes("exceeds") ? 413 : 400;
+			respondJson(res, status, { ok: false, error: message });
+			return;
+		}
+
+		let parsedBody: unknown;
+		try {
+			parsedBody = rawBody ? JSON.parse(rawBody) : {};
+		} catch {
+			respondJson(res, 400, { ok: false, error: "Invalid JSON body." });
+			return;
+		}
+
+		const markdown =
+			parsedBody && typeof parsedBody === "object" && typeof (parsedBody as { markdown?: unknown }).markdown === "string"
+				? (parsedBody as { markdown: string }).markdown
+				: null;
+		if (markdown === null) {
+			respondJson(res, 400, { ok: false, error: "Missing markdown string in request body." });
+			return;
+		}
+
+		if (markdown.length > PDF_EXPORT_MAX_CHARS) {
+			respondJson(res, 413, {
+				ok: false,
+				error: `PDF export text exceeds ${PDF_EXPORT_MAX_CHARS} characters.`,
+			});
+			return;
+		}
+
+		const sourcePath =
+			parsedBody && typeof parsedBody === "object" && typeof (parsedBody as { sourcePath?: unknown }).sourcePath === "string"
+				? (parsedBody as { sourcePath: string }).sourcePath
+				: "";
+		const userResourceDir =
+			parsedBody && typeof parsedBody === "object" && typeof (parsedBody as { resourceDir?: unknown }).resourceDir === "string"
+				? (parsedBody as { resourceDir: string }).resourceDir
+				: "";
+		const resourcePath = sourcePath ? dirname(sourcePath) : (userResourceDir || studioCwd || undefined);
+		const requestedIsLatex =
+			parsedBody && typeof parsedBody === "object" && typeof (parsedBody as { isLatex?: unknown }).isLatex === "boolean"
+				? (parsedBody as { isLatex: boolean }).isLatex
+				: null;
+		const isLatex = requestedIsLatex ?? /\\documentclass\b|\\begin\{document\}/.test(markdown);
+		const requestedFilename =
+			parsedBody && typeof parsedBody === "object" && typeof (parsedBody as { filenameHint?: unknown }).filenameHint === "string"
+				? (parsedBody as { filenameHint: string }).filenameHint
+				: "";
+		const filename = sanitizePdfFilename(requestedFilename || (isLatex ? "studio-latex-preview.pdf" : "studio-preview.pdf"));
+
+		try {
+			const pdf = await renderStudioPdfWithPandoc(markdown, isLatex, resourcePath);
+			const safeAsciiName = filename
+				.replace(/[\x00-\x1f\x7f]/g, "")
+				.replace(/[;"\\]/g, "_")
+				.replace(/\s+/g, " ")
+				.trim() || "studio-preview.pdf";
+
+			res.writeHead(200, {
+				"Content-Type": "application/pdf",
+				"Cache-Control": "no-store",
+				"X-Content-Type-Options": "nosniff",
+				"Content-Disposition": `attachment; filename="${safeAsciiName}"; filename*=UTF-8''${encodeURIComponent(filename)}`,
+				"Content-Length": String(pdf.length),
+			});
+			res.end(pdf);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			respondJson(res, 500, { ok: false, error: `PDF export failed: ${message}` });
+		}
+	};
+
 	const handleHttpRequest = (req: IncomingMessage, res: ServerResponse) => {
 		if (!serverState) {
 			respondText(res, 503, "Studio server not ready");
@@ -4834,6 +6026,29 @@ export default function (pi: ExtensionAPI) {
 			return;
 		}
 
+		if (requestUrl.pathname === "/export-pdf") {
+			const token = requestUrl.searchParams.get("token") ?? "";
+			if (token !== serverState.token) {
+				respondJson(res, 403, { ok: false, error: "Invalid or expired studio token. Re-run /studio." });
+				return;
+			}
+
+			const method = (req.method ?? "GET").toUpperCase();
+			if (method !== "POST") {
+				res.setHeader("Allow", "POST");
+				respondJson(res, 405, { ok: false, error: "Method not allowed. Use POST." });
+				return;
+			}
+
+			void handleExportPdfRequest(req, res).catch((error) => {
+				respondJson(res, 500, {
+					ok: false,
+					error: `PDF export failed: ${error instanceof Error ? error.message : String(error)}`,
+				});
+			});
+			return;
+		}
+
 		if (requestUrl.pathname !== "/") {
 			respondText(res, 404, "Not found");
 			return;
@@ -4853,7 +6068,7 @@ export default function (pi: ExtensionAPI) {
 			"Cross-Origin-Opener-Policy": "same-origin",
 			"Cross-Origin-Resource-Policy": "same-origin",
 		});
-		res.end(buildStudioHtml(initialStudioDocument, lastCommandCtx?.ui.theme));
+		res.end(buildStudioHtml(initialStudioDocument, lastCommandCtx?.ui.theme, currentModelLabel, terminalSessionLabel));
 	};
 
 	const ensureServer = async (): Promise<StudioServerState> => {
@@ -4945,9 +6160,22 @@ export default function (pi: ExtensionAPI) {
 
 		serverState = state;
 
-		// Periodically check for theme changes and push to all clients
+		// Periodically check for theme/model metadata changes and push to all clients
 		const themeCheckInterval = setInterval(() => {
-			if (!lastCommandCtx?.ui?.theme || !serverState || serverState.clients.size === 0) return;
+			if (!serverState || serverState.clients.size === 0) return;
+
+			try {
+				const previousModelLabel = currentModelLabel;
+				const previousTerminalLabel = terminalSessionLabel;
+				refreshRuntimeMetadata();
+				if (currentModelLabel !== previousModelLabel || terminalSessionLabel !== previousTerminalLabel) {
+					broadcastState();
+				}
+			} catch {
+				// Ignore metadata read errors
+			}
+
+			if (!lastCommandCtx?.ui?.theme) return;
 			try {
 				const style = getStudioThemeStyle(lastCommandCtx.ui.theme);
 				const vars = buildThemeCssVars(style);
@@ -5004,21 +6232,101 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_start", async (_event, ctx) => {
 		hydrateLatestAssistant(ctx.sessionManager.getBranch());
+		agentBusy = false;
+		refreshRuntimeMetadata(ctx);
+		emitDebugEvent("session_start", {
+			entryCount: ctx.sessionManager.getBranch().length,
+			modelLabel: currentModelLabel,
+			terminalSessionLabel,
+		});
+		setTerminalActivity("idle");
 	});
 
 	pi.on("session_switch", async (_event, ctx) => {
 		clearActiveRequest({ notify: "Session switched. Studio request state cleared.", level: "warning" });
 		lastCommandCtx = null;
 		hydrateLatestAssistant(ctx.sessionManager.getBranch());
+		agentBusy = false;
+		refreshRuntimeMetadata(ctx);
+		emitDebugEvent("session_switch", {
+			entryCount: ctx.sessionManager.getBranch().length,
+			modelLabel: currentModelLabel,
+			terminalSessionLabel,
+		});
+		setTerminalActivity("idle");
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		refreshRuntimeMetadata({ cwd: ctx.cwd, model: event.model });
+		emitDebugEvent("model_select", {
+			modelLabel: currentModelLabel,
+			source: event.source,
+			previousModel: formatModelLabel(event.previousModel),
+		});
+		broadcastState();
 	});
 
 	pi.on("agent_start", async () => {
 		agentBusy = true;
-		broadcastState();
+		emitDebugEvent("agent_start", { activeRequestId: activeRequest?.id ?? null, activeRequestKind: activeRequest?.kind ?? null });
+		setTerminalActivity("running");
+	});
+
+	pi.on("tool_call", async (event) => {
+		if (!agentBusy) return;
+		const toolName = typeof event.toolName === "string" ? event.toolName : "";
+		const input = (event as { input?: unknown }).input;
+		const label = deriveToolActivityLabel(toolName, input);
+		emitDebugEvent("tool_call", { toolName, label, activeRequestId: activeRequest?.id ?? null, activeRequestKind: activeRequest?.kind ?? null });
+		setTerminalActivity("tool", toolName, label);
+	});
+
+	pi.on("tool_execution_start", async (event) => {
+		if (!agentBusy) return;
+		const label = deriveToolActivityLabel(event.toolName, event.args);
+		emitDebugEvent("tool_execution_start", { toolName: event.toolName, label, activeRequestId: activeRequest?.id ?? null, activeRequestKind: activeRequest?.kind ?? null });
+		setTerminalActivity("tool", event.toolName, label);
+	});
+
+	pi.on("tool_execution_end", async (event) => {
+		if (!agentBusy) return;
+		emitDebugEvent("tool_execution_end", { toolName: event.toolName, activeRequestId: activeRequest?.id ?? null, activeRequestKind: activeRequest?.kind ?? null });
+		// Keep tool phase visible until the next tool call, assistant response phase,
+		// or agent_end. This avoids tool labels flashing too quickly to read.
+	});
+
+	pi.on("message_start", async (event) => {
+		const role = (event.message as { role?: string } | undefined)?.role;
+		emitDebugEvent("message_start", { role: role ?? "", activeRequestId: activeRequest?.id ?? null, activeRequestKind: activeRequest?.kind ?? null });
+		if (agentBusy && role === "assistant") {
+			setTerminalActivity("responding");
+		}
 	});
 
 	pi.on("message_end", async (event) => {
+		const message = event.message as { stopReason?: string; role?: string };
+		const stopReason = typeof message.stopReason === "string" ? message.stopReason : "";
+		const role = typeof message.role === "string" ? message.role : "";
 		const markdown = extractAssistantText(event.message);
+		emitDebugEvent("message_end", {
+			role,
+			stopReason,
+			hasMarkdown: Boolean(markdown),
+			markdownLength: markdown ? markdown.length : 0,
+			activeRequestId: activeRequest?.id ?? null,
+			activeRequestKind: activeRequest?.kind ?? null,
+		});
+
+		// Assistant is handing off to tool calls; request is still in progress.
+		if (stopReason === "toolUse") {
+			emitDebugEvent("message_end_tool_use", {
+				role,
+				activeRequestId: activeRequest?.id ?? null,
+				activeRequestKind: activeRequest?.kind ?? null,
+			});
+			return;
+		}
+
 		if (!markdown) return;
 
 		if (activeRequest) {
@@ -5029,6 +6337,12 @@ export default function (pi: ExtensionAPI) {
 				timestamp: Date.now(),
 				kind,
 			};
+			emitDebugEvent("broadcast_response", {
+				requestId,
+				kind,
+				markdownLength: markdown.length,
+				stopReason,
+			});
 			broadcast({
 				type: "response",
 				requestId,
@@ -5046,6 +6360,11 @@ export default function (pi: ExtensionAPI) {
 			timestamp: Date.now(),
 			kind: inferredKind,
 		};
+		emitDebugEvent("broadcast_latest_response", {
+			kind: inferredKind,
+			markdownLength: markdown.length,
+			stopReason,
+		});
 		broadcast({
 			type: "latest_response",
 			kind: inferredKind,
@@ -5056,7 +6375,8 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("agent_end", async () => {
 		agentBusy = false;
-		broadcastState();
+		emitDebugEvent("agent_end", { activeRequestId: activeRequest?.id ?? null, activeRequestKind: activeRequest?.kind ?? null });
+		setTerminalActivity("idle");
 		if (activeRequest) {
 			const requestId = activeRequest.id;
 			broadcast({
@@ -5070,6 +6390,8 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_shutdown", async () => {
 		lastCommandCtx = null;
+		agentBusy = false;
+		setTerminalActivity("idle");
 		await stopServer();
 	});
 
@@ -5112,7 +6434,8 @@ export default function (pi: ExtensionAPI) {
 
 			await ctx.waitForIdle();
 			lastCommandCtx = ctx;
-			studioCwd = ctx.cwd;
+			refreshRuntimeMetadata(ctx);
+			broadcastState();
 			// Seed theme vars so first ping doesn't trigger a false update
 			try {
 				const currentStyle = getStudioThemeStyle(ctx.ui.theme);