pi-studio 0.5.14 → 0.5.15

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to `pi-studio` are documented here.
 
 ## [Unreleased]
 
+## [0.5.15] — 2026-03-16
+
+### Added
+- Per-pane **Focus pane** controls for both the editor and response panes, matching the current Ghostty/cmux split-browser workflow more directly.
+- cmux-aware Studio completion notifications with safer workspace-level targeting, a running/compacting sidebar status pill, stale-notification clearing when a new Studio request starts, and suppression when the Studio browser surface is already focused.
+
+### Fixed
+- Active **Focus pane** buttons now keep their accent-coloured hover state instead of switching to a dark hover style.
+- PDF export now defines the LaTeX `Highlighting` environment when Pandoc has not already created it, fixing exports that previously failed with `Environment Highlighting undefined`.
+
 ## [0.5.14] — 2026-03-15
 
 ### Fixed

package/WORKFLOW.md

@@ -1,4 +1,4 @@
-# pi-studio workflow spec (v0.2 draft)
+# pi-studio workflow/spec note
 
 ## Goal
 
@@ -7,9 +7,9 @@ Keep Studio simple while supporting both loops:
 1. **User → model feedback** (annotated reply)
 2. **Model → user critique** (structured critique package)
 
-Studio uses a **single workspace** (no tab/mode switching):
+Studio uses a **single workspace**:
 - left pane: **Editor**
-- right pane: **Response**
+- right pane: **Response / Thinking / Editor Preview**
 
 ---
 
@@ -46,17 +46,23 @@ Critiques current editor text and expects/handles structured output:
 
 ## Response handling
 
-Right pane always shows the **latest assistant response** (reply or critique).
+By default, the right pane follows the latest assistant response, but Studio can also:
+- browse older assistant responses via response history
+- show **Thinking (Raw)** for the currently selected response when available
+- show **Editor (Preview)** for the current editor text
 
-When response is structured critique, Studio enables additional helpers:
+When the selected response is structured critique, Studio enables additional helpers:
 - **Load critique (notes)** (`## Assessment` + `## Critiques`)
 - **Load critique (full)** (`## Assessment` + `## Critiques` + `## Document`)
 
 For non-critique responses:
 - **Load response into editor**
 
-Always available:
-- **Copy response**
+In Thinking view (when available):
+- **Load thinking into editor**
+- **Copy thinking text**
+
+Otherwise, Studio supports copying the currently viewed response text.
 
 ---
 
@@ -75,11 +81,11 @@ Rules:
 
 ## Required UI elements
 
-- Header actions: **Save As…**, **Save file** (file-backed), **Load file in editor**
-- Header view toggles: `Left: Editor (Raw|Preview)`, `Right: Response (Raw|Preview) | Editor (Preview)`
+- Header actions: **Save As…**, **Save file** (file-backed), **Load file content**
+- Header view toggles: `Left: Editor (Raw|Preview)`, `Right: Response (Raw|Preview) | Thinking (Raw) | Editor (Preview)`
 - Preview mode uses server-side `pandoc` rendering (math-aware) with plain-markdown fallback when renderer is unavailable.
 - Editor actions: **Insert/Remove annotated reply header**, **Annotations: On|Hidden**, **Strip annotations…**, **Run editor text**, **Critique editor text** (+ critique focus), **Send to pi editor**, **Copy editor text**, **Save .annotated.md**
-- Response actions include `Auto-update response: On|Off`, **Fetch latest response**, response-history browse (`Prev/Next/Last`), **Load response into editor**, and **Load response prompt into editor**
+- Response actions include `Auto-update response: On|Off`, **Fetch latest response**, response-history browse (`Prev/Next/Last`), **Load response into editor**, **Load response prompt into editor**, and thinking-aware load/copy actions when Thinking view is active
 - Source badge: `blank | last model response | file <path> | upload`
 - Response badge: `none | assistant response | assistant critique` (+ timestamp)
 - Sync badge: shown only when the editor exactly matches the currently viewed response/thinking (`In sync with response | In sync with thinking`)
@@ -89,13 +95,13 @@ Rules:
 
 ## Escaping pitfalls (implementation note)
 
-`index.ts` builds browser HTML as a TypeScript template string and embeds inline browser JavaScript. This creates multiple parse layers (TS string → HTML → JS), so incorrect escaping can break Studio boot (e.g. stuck at `Booting studio…`).
+Studio is less fragile than before because browser JS/CSS now live in extracted client files, but `index.ts` still builds the HTML shell and injects boot/theme/source values. Incorrect escaping can still break Studio boot.
 
 Rules of thumb:
-- In embedded JS string literals authored from TS template context, use `\\n` (not `\n`) for runtime newlines.
-- Escape regex backslashes for the embedding layer (`\\s`, `\\n`, `\\[`), so browser JS receives the intended regex.
-- Prefer `JSON.stringify(value)` when injecting arbitrary text into inline script.
-- After touching inline `<script>` sections in `index.ts`, do a `/studio` boot smoke test immediately.
+- Prefer `JSON.stringify(value)` when injecting arbitrary text into boot data or script-adjacent HTML.
+- Be careful with HTML attribute escaping for injected values.
+- After touching the HTML shell / boot-data wiring in `index.ts`, do a `/studio` boot smoke test immediately.
+- After touching `client/studio-client.js` or `client/studio.css`, smoke test the main workflows: boot, websocket connect/reconnect, file load, run/critique, preview, and response history.
 
 ## Acceptance criteria
 

package/client/studio-client.js

@@ -85,6 +85,8 @@
       const langSelect = document.getElementById("langSelect");
       const annotationModeSelect = document.getElementById("annotationModeSelect");
       const compactBtn = document.getElementById("compactBtn");
+      const leftFocusBtn = document.getElementById("leftFocusBtn");
+      const rightFocusBtn = document.getElementById("rightFocusBtn");
 
       const initialSourceState = {
         source: (document.body && document.body.dataset && document.body.dataset.initialSource) || "blank",
@@ -697,6 +699,23 @@
         }
       }
 
+      function updatePaneFocusButtons() {
+        [
+          [leftFocusBtn, "left"],
+          [rightFocusBtn, "right"],
+        ].forEach(([btn, pane]) => {
+          if (!btn) return;
+          const isFocusedPane = paneFocusTarget === pane;
+          const paneName = pane === "right" ? "response" : "editor";
+          btn.classList.toggle("is-active", isFocusedPane);
+          btn.setAttribute("aria-pressed", isFocusedPane ? "true" : "false");
+          btn.textContent = isFocusedPane ? "Exit focus" : "Focus pane";
+          btn.title = isFocusedPane
+            ? "Exit focus mode for the " + paneName + " pane."
+            : "Show only the " + paneName + " pane. Shortcut: Cmd/Ctrl+Esc or F10.";
+        });
+      }
+
       function applyPaneFocusClasses() {
         document.body.classList.remove("pane-focus-left", "pane-focus-right");
         if (paneFocusTarget === "left") {
@@ -704,6 +723,7 @@
         } else if (paneFocusTarget === "right") {
           document.body.classList.add("pane-focus-right");
         }
+        updatePaneFocusButtons();
       }
 
       function setActivePane(nextPane) {
@@ -725,6 +745,14 @@
         return "Editor";
       }
 
+      function enterPaneFocus(nextPane) {
+        const pane = nextPane === "right" ? "right" : "left";
+        setActivePane(pane);
+        paneFocusTarget = pane;
+        applyPaneFocusClasses();
+        setStatus("Focus mode: " + paneLabel(pane) + " pane (Esc to exit).");
+      }
+
       function togglePaneFocus() {
         if (paneFocusTarget === activePane) {
           paneFocusTarget = "off";
@@ -733,9 +761,7 @@
           return;
         }
 
-        paneFocusTarget = activePane;
-        applyPaneFocusClasses();
-        setStatus("Focus mode: " + paneLabel(activePane) + " pane (Esc to exit).");
+        enterPaneFocus(activePane);
       }
 
       function exitPaneFocus() {
@@ -3420,6 +3446,27 @@
         rightPaneEl.addEventListener("focusin", () => setActivePane("right"));
       }
 
+      if (leftFocusBtn) {
+        leftFocusBtn.addEventListener("click", () => {
+          if (paneFocusTarget === "left") {
+            exitPaneFocus();
+            return;
+          }
+          enterPaneFocus("left");
+        });
+      }
+
+      if (rightFocusBtn) {
+        rightFocusBtn.addEventListener("click", () => {
+          if (paneFocusTarget === "right") {
+            exitPaneFocus();
+            return;
+          }
+          enterPaneFocus("right");
+        });
+      }
+
+      updatePaneFocusButtons();
       window.addEventListener("keydown", handlePaneShortcut);
       window.addEventListener("beforeunload", () => {
         stopFooterSpinner();

package/client/studio.css

@@ -203,6 +203,20 @@
       border-radius: 7px;
     }
 
+    .pane-focus-btn.is-active {
+      background: var(--accent);
+      border-color: var(--accent);
+      color: var(--accent-contrast);
+      font-weight: 600;
+    }
+
+    button.pane-focus-btn.is-active:not(:disabled):hover {
+      background: var(--accent);
+      border-color: var(--accent);
+      color: var(--accent-contrast);
+      filter: brightness(0.95);
+    }
+
     .section-header select {
       font-weight: 600;
       font-size: 14px;

package/index.ts

@@ -156,6 +156,9 @@ const PDF_EXPORT_MAX_CHARS = 400_000;
 const REQUEST_BODY_MAX_BYTES = 1_000_000;
 const RESPONSE_HISTORY_LIMIT = 30;
 const UPDATE_CHECK_TIMEOUT_MS = 1800;
+const CMUX_NOTIFY_TIMEOUT_MS = 1200;
+const STUDIO_TERMINAL_NOTIFY_TITLE = "pi Studio";
+const CMUX_STUDIO_STATUS_KEY = "pi_studio";
 
 const PDF_PREAMBLE = `\\usepackage{titlesec}
 \\titleformat{\\section}{\\Large\\bfseries\\sffamily}{}{0pt}{}[\\vspace{2pt}\\titlerule]
@@ -168,7 +171,13 @@ const PDF_PREAMBLE = `\\usepackage{titlesec}
 \\setlist[enumerate]{nosep, leftmargin=1.5em}
 \\usepackage{parskip}
 \\usepackage{fvextra}
-\\RecustomVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\\\\{\\},breaklines,breakanywhere}
+\\makeatletter
+\\@ifundefined{Highlighting}{%
+  \\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\\\\{\\},breaklines,breakanywhere}%
+}{%
+  \\RecustomVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\\\\{\\},breaklines,breakanywhere}%
+}
+\\makeatother
 `;
 
 type StudioThemeMode = "dark" | "light";
@@ -2765,10 +2774,15 @@ ${cssVarsBlock}
   <main>
     <section id="leftPane">
       <div id="leftSectionHeader" class="section-header">
-        <select id="editorViewSelect" aria-label="Editor view mode">
-          <option value="markdown" selected>Editor (Raw)</option>
-          <option value="preview">Editor (Preview)</option>
-        </select>
+        <div class="section-header-main">
+          <select id="editorViewSelect" aria-label="Editor view mode">
+            <option value="markdown" selected>Editor (Raw)</option>
+            <option value="preview">Editor (Preview)</option>
+          </select>
+        </div>
+        <div class="section-header-actions">
+          <button id="leftFocusBtn" class="pane-focus-btn" type="button" title="Show only the editor pane. Shortcut: Cmd/Ctrl+Esc or F10.">Focus pane</button>
+        </div>
       </div>
       <div class="source-wrap">
         <div class="source-meta">
@@ -2858,6 +2872,7 @@ ${cssVarsBlock}
           </select>
         </div>
         <div class="section-header-actions">
+          <button id="rightFocusBtn" class="pane-focus-btn" type="button" title="Show only the response pane. Shortcut: Cmd/Ctrl+Esc or F10.">Focus pane</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>
@@ -2990,6 +3005,246 @@ export default function (pi: ExtensionAPI) {
 		lastCommandCtx.ui.notify(message, level);
 	};
 
+	const getStudioTerminalNotifyMode = (): "auto" | "off" | "bell" | "cmux" | "text" => {
+		const raw = String(process.env.PI_STUDIO_TERMINAL_NOTIFY ?? "").trim().toLowerCase();
+		if (raw === "off" || raw === "none") return "off";
+		if (raw === "bell") return "bell";
+		if (raw === "cmux") return "cmux";
+		if (raw === "text" || raw === "line") return "text";
+		return "auto";
+	};
+
+	const getInteractiveTerminalStream = (): NodeJS.WriteStream | null => {
+		if (process.stderr?.isTTY) return process.stderr;
+		if (process.stdout?.isTTY) return process.stdout;
+		return null;
+	};
+
+	const isProbablyCmuxSession = (): boolean => {
+		const workspaceId = String(process.env.CMUX_WORKSPACE_ID ?? "").trim();
+		if (workspaceId) return true;
+		const termProgram = String(process.env.TERM_PROGRAM ?? "").trim().toLowerCase();
+		if (termProgram === "cmux") return true;
+		const term = String(process.env.TERM ?? "").trim().toLowerCase();
+		return term.includes("cmux");
+	};
+
+	const sanitizeTerminalNotificationText = (value: string, maxLength = 240): string => {
+		const sanitized = String(value)
+			.replace(/[\u0000-\u0008\u000b-\u001a\u001c-\u001f\u007f]+/g, " ")
+			.replace(/\u001b/g, "")
+			.replace(/[;|\r\n]+/g, " ")
+			.replace(/\s+/g, " ")
+			.trim();
+		return sanitized.slice(0, maxLength);
+	};
+
+	const shouldUseCmuxTerminalIntegration = (): boolean => {
+		const mode = getStudioTerminalNotifyMode();
+		return isProbablyCmuxSession() && (mode === "auto" || mode === "cmux");
+	};
+
+	const getCmuxWorkspaceArgs = (): string[] => {
+		const workspaceId = String(process.env.CMUX_WORKSPACE_ID ?? "").trim();
+		return workspaceId ? ["--workspace", workspaceId] : [];
+	};
+
+	const runCmuxCommand = (args: string[], options?: { captureOutput?: boolean }): { ok: boolean; stdout: string } => {
+		try {
+			const env = { ...process.env };
+			delete env.CMUX_SURFACE_ID;
+			const result = spawnSync("cmux", args, {
+				stdio: options?.captureOutput ? ["ignore", "pipe", "ignore"] : "ignore",
+				encoding: options?.captureOutput ? "utf8" : undefined,
+				timeout: CMUX_NOTIFY_TIMEOUT_MS,
+				env,
+			});
+			const stdout = typeof result.stdout === "string" ? result.stdout : "";
+			return {
+				ok: !result.error && result.status === 0,
+				stdout,
+			};
+		} catch {
+			return { ok: false, stdout: "" };
+		}
+	};
+
+	const isCmuxBrowserFocusedInCallerWorkspace = (): boolean => {
+		if (!shouldUseCmuxTerminalIntegration()) return false;
+		const result = runCmuxCommand(["identify"], { captureOutput: true });
+		if (!result.ok) return false;
+		try {
+			const parsed = JSON.parse(result.stdout) as {
+				caller?: { workspace_ref?: string | null };
+				focused?: { workspace_ref?: string | null; surface_type?: string | null; is_browser_surface?: boolean | null };
+			};
+			const callerWorkspaceRef = typeof parsed.caller?.workspace_ref === "string"
+				? parsed.caller.workspace_ref.trim()
+				: "";
+			const focusedWorkspaceRef = typeof parsed.focused?.workspace_ref === "string"
+				? parsed.focused.workspace_ref.trim()
+				: "";
+			const focusedSurfaceType = typeof parsed.focused?.surface_type === "string"
+				? parsed.focused.surface_type.trim().toLowerCase()
+				: "";
+			const focusedIsBrowser = parsed.focused?.is_browser_surface === true || focusedSurfaceType === "browser";
+			return Boolean(callerWorkspaceRef && focusedWorkspaceRef && callerWorkspaceRef === focusedWorkspaceRef && focusedIsBrowser);
+		} catch {
+			return false;
+		}
+	};
+
+	const maybeClearStaleCmuxStudioNotifications = () => {
+		if (!shouldUseCmuxTerminalIntegration()) return;
+		const result = runCmuxCommand(["list-notifications"], { captureOutput: true });
+		if (!result.ok) return;
+		const output = result.stdout.trim();
+		if (!output) return;
+		const notifications = output
+			.split(/\r?\n/)
+			.map((line) => {
+				const trimmed = line.trim();
+				if (!trimmed) return null;
+				const colonIndex = trimmed.indexOf(":");
+				if (colonIndex === -1) return null;
+				const fields = trimmed.slice(colonIndex + 1).split("|");
+				if (fields.length !== 7) return null;
+				const [, , , state, title] = fields;
+				return {
+					state,
+					title,
+				};
+			});
+		if (notifications.some((item) => item === null)) return;
+		const clearable = notifications.every(
+			(item) => item && item.state === "read" && item.title === STUDIO_TERMINAL_NOTIFY_TITLE,
+		);
+		if (!clearable) return;
+		runCmuxCommand(["clear-notifications"]);
+	};
+
+	const syncCmuxStudioStatus = () => {
+		if (!shouldUseCmuxTerminalIntegration()) return;
+		const workspaceArgs = getCmuxWorkspaceArgs();
+		if (activeRequest) {
+			runCmuxCommand([
+				"set-status",
+				CMUX_STUDIO_STATUS_KEY,
+				"running…",
+				"--color",
+				"#5ea1ff",
+				...workspaceArgs,
+			]);
+			return;
+		}
+		if (compactInProgress) {
+			runCmuxCommand([
+				"set-status",
+				CMUX_STUDIO_STATUS_KEY,
+				"compacting…",
+				"--color",
+				"#5ea1ff",
+				...workspaceArgs,
+			]);
+			return;
+		}
+		runCmuxCommand(["clear-status", CMUX_STUDIO_STATUS_KEY, ...workspaceArgs]);
+	};
+
+	const emitTerminalBell = (): boolean => {
+		const stream = getInteractiveTerminalStream();
+		if (!stream) return false;
+		try {
+			stream.write("\u0007");
+			return true;
+		} catch {
+			return false;
+		}
+	};
+
+	const emitTerminalTextNotification = (message: string): boolean => {
+		const stream = getInteractiveTerminalStream();
+		if (!stream) return false;
+		const line = sanitizeTerminalNotificationText(message, 400);
+		if (!line) return false;
+		try {
+			stream.write(`\n[pi Studio] ${line}\n`);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+
+	const emitCmuxOscNotification = (message: string): boolean => {
+		const stream = getInteractiveTerminalStream();
+		if (!stream) return false;
+		const title = sanitizeTerminalNotificationText(STUDIO_TERMINAL_NOTIFY_TITLE, 80);
+		const body = sanitizeTerminalNotificationText(message, 240);
+		if (!body) return false;
+		try {
+			stream.write(`\u001b]777;notify;${title};${body}\u0007`);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+
+	const emitCmuxCliNotification = (message: string): boolean => {
+		const body = sanitizeTerminalNotificationText(message, 240);
+		if (!body) return false;
+		return runCmuxCommand([
+			"notify",
+			"--title",
+			STUDIO_TERMINAL_NOTIFY_TITLE,
+			"--body",
+			body,
+			...getCmuxWorkspaceArgs(),
+		]).ok;
+	};
+
+	const notifyStudioTerminal = (message: string, level: "info" | "warning" | "error" = "info") => {
+		const mode = getStudioTerminalNotifyMode();
+		const hasInteractiveTerminal = Boolean(getInteractiveTerminalStream());
+		const inCmux = isProbablyCmuxSession();
+		const useCmuxIntegration = shouldUseCmuxTerminalIntegration();
+		const suppressCmuxCompletionNotification = useCmuxIntegration && isCmuxBrowserFocusedInCallerWorkspace();
+		let deliveredBy: "cmux-cli" | "cmux-osc777" | "bell" | "text" | null = null;
+
+		if (useCmuxIntegration && !suppressCmuxCompletionNotification) {
+			if (emitCmuxCliNotification(message)) {
+				deliveredBy = "cmux-cli";
+			} else if (emitCmuxOscNotification(message)) {
+				deliveredBy = "cmux-osc777";
+			}
+		}
+
+		if (!deliveredBy && !suppressCmuxCompletionNotification) {
+			if (mode === "text") {
+				if (emitTerminalTextNotification(message)) deliveredBy = "text";
+			} else if (mode === "bell") {
+				if (emitTerminalBell()) deliveredBy = "bell";
+			} else if (mode === "auto") {
+				if (emitTerminalBell()) deliveredBy = "bell";
+			}
+		}
+
+		emitDebugEvent("terminal_notification", {
+			message,
+			level,
+			mode,
+			inCmux,
+			hasInteractiveTerminal,
+			suppressCmuxCompletionNotification,
+			delivered: Boolean(deliveredBy),
+			deliveredBy,
+		});
+	};
+
+	const getStudioRequestCompletionNotification = (kind: StudioRequestKind): string => {
+		if (kind === "critique") return "Studio: critique ready.";
+		return "Studio: response ready.";
+	};
+
 	const refreshContextUsage = (
 		ctx?: { getContextUsage(): { tokens: number | null; contextWindow: number; percent: number | null } | undefined },
 	): StudioContextUsageSnapshot => {
@@ -3002,6 +3257,7 @@ export default function (pi: ExtensionAPI) {
 	const clearCompactionState = () => {
 		compactInProgress = false;
 		compactRequestId = null;
+		syncCmuxStudioStatus();
 	};
 
 	const syncStudioResponseHistory = (entries: SessionEntry[]) => {
@@ -3157,22 +3413,34 @@ export default function (pi: ExtensionAPI) {
 		});
 	};
 
-	const clearActiveRequest = (options?: { notify?: string; level?: "info" | "warning" | "error" }) => {
+	const clearActiveRequest = (options?: {
+		notify?: string;
+		level?: "info" | "warning" | "error";
+		terminalNotify?: string;
+		terminalNotifyLevel?: "info" | "warning" | "error";
+	}) => {
 		if (!activeRequest) return;
 		const completedRequestId = activeRequest.id;
 		const completedKind = activeRequest.kind;
 		clearTimeout(activeRequest.timer);
 		activeRequest = null;
+		syncCmuxStudioStatus();
 		emitDebugEvent("clear_active_request", {
 			requestId: completedRequestId,
 			kind: completedKind,
 			notify: options?.notify ?? null,
+			terminalNotify: options?.terminalNotify ?? null,
 			agentBusy,
 		});
 		broadcastState();
 		if (options?.notify) {
 			broadcast({ type: "info", message: options.notify, level: options.level ?? "info" });
 		}
+		if (options?.terminalNotify) {
+			const terminalLevel = options.terminalNotifyLevel ?? options.level ?? "info";
+			notifyStudio(options.terminalNotify, terminalLevel);
+			notifyStudioTerminal(options.terminalNotify, terminalLevel);
+		}
 	};
 
 	const cancelActiveRequest = (requestId: string): { ok: true; kind: StudioRequestKind } | { ok: false; message: string } => {
@@ -3236,6 +3504,8 @@ export default function (pi: ExtensionAPI) {
 			startedAt: Date.now(),
 			timer,
 		};
+		maybeClearStaleCmuxStudioNotifications();
+		syncCmuxStudioStatus();
 
 		emitDebugEvent("begin_request", { requestId, kind });
 		broadcast({ type: "request_started", requestId, kind });
@@ -3488,6 +3758,8 @@ export default function (pi: ExtensionAPI) {
 
 			compactInProgress = true;
 			compactRequestId = msg.requestId;
+			maybeClearStaleCmuxStudioNotifications();
+			syncCmuxStudioStatus();
 			refreshContextUsage(compactCtx);
 			emitDebugEvent("compact_start", {
 				requestId: msg.requestId,
@@ -4322,7 +4594,10 @@ export default function (pi: ExtensionAPI) {
 				responseHistory: studioResponseHistory,
 			});
 			broadcastResponseHistory();
-			clearActiveRequest();
+			clearActiveRequest({
+				terminalNotify: getStudioRequestCompletionNotification(kind),
+				terminalNotifyLevel: "info",
+			});
 			return;
 		}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-studio",
-  "version": "0.5.14",
+  "version": "0.5.15",
   "description": "Browser GUI for structured critique workflows in pi",
   "type": "module",
   "license": "MIT",