pi-lean-dimension 0.5.0 → 0.6.0

package/node_modules/pi-lean-portal/browser-install.ts

@@ -0,0 +1,454 @@
+/**
+ * Browser Install — `/web install` subcommand.
+ *
+ * The `playwright` npm package ships no browser binaries, and the generic
+ * `npx playwright install` advice can resolve a different playwright copy
+ * than the one the backends import — installing revisions the backends
+ * don't match. This command resolves the *bundled* playwright CLI (the same
+ * copy the backends use) and downloads engines from it, guaranteeing
+ * revision parity.
+ *
+ * Forms:
+ *   /web install            — checkbox dialog (TUI only; other modes print
+ *                             the manual bundled-CLI command)
+ *   /web install chromium   — direct download, no dialog (TUI + RPC spawn;
+ *                             print/JSON modes print the manual command)
+ *
+ * Never throws: resolution, detection, and download failures all fall back
+ * to printing a manual command. Removal is intentionally out of scope —
+ * `playwright uninstall` takes no per-engine arguments and the cache
+ * directory is machine-global; document the real CLI instead.
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	Container,
+	type SelectItem,
+	SelectList,
+	Text,
+} from "@earendil-works/pi-tui";
+
+// ─── Engines ─────────────────────────────────────────────────────
+
+export const ENGINES = ["chromium", "firefox"] as const;
+export type Engine = (typeof ENGINES)[number];
+
+/** Rough per-engine download sizes, for the dialog rows. */
+const ENGINE_SIZES = {
+	chromium: "~170 MB",
+	firefox: "~90 MB",
+} as const;
+
+// ─── Bundled playwright resolution ───────────────────────────────
+
+export interface BundledPlaywright {
+	/** The playwright module the backends import (same copy, same revisions). */
+	pw: typeof import("playwright");
+	/** Absolute path to the bundled playwright CLI entry. */
+	cliJs: string;
+	/** Node interpreter for spawning the CLI. */
+	nodeExe: string;
+}
+
+/**
+ * Node interpreter for spawning the bundled CLI. `process.execPath` is only
+ * a Node binary under the npm-shim distribution; pi also ships a
+ * bun-compiled standalone binary where `process.execPath` is the pi binary
+ * itself — spawning it with playwright's args re-runs pi, not the CLI. The
+ * `.exe` strip handles Windows (`...\node.exe` there); on POSIX the replace
+ * is a no-op.
+ */
+export function resolveNodeInterpreter(): string {
+	return basename(process.execPath).replace(/\.exe$/i, "") === "node"
+		? process.execPath
+		: "node";
+}
+
+/**
+ * Resolve the bundled playwright module + CLI path. Throws if playwright is
+ * missing entirely (corrupted install) — callers must catch and fall back to
+ * the generic manual command. Must be called lazily (inside the command
+ * handler), never at module top level: this module is imported by the `/web`
+ * dispatcher, and a throwing top-level require would break the entire `/web`
+ * command in exactly the corrupt-install scenario this command exists for.
+ */
+export function resolveBundledPlaywright(): BundledPlaywright {
+	const req = createRequire(import.meta.url);
+	const pw = req("playwright");
+	// `playwright/package.json` is exported; `playwright/cli.js` is not —
+	// resolving the CLI subpath directly throws ERR_PACKAGE_PATH_NOT_EXPORTED.
+	const pkgDir = dirname(req.resolve("playwright/package.json"));
+	return {
+		pw,
+		cliJs: join(pkgDir, "cli.js"),
+		nodeExe: resolveNodeInterpreter(),
+	};
+}
+
+// ─── Installed-browser detection (no launch) ─────────────────────
+
+export interface BrowserDetection {
+	chromium: boolean;
+	firefox: boolean;
+}
+
+/**
+ * Detect installed Node-backend browsers without launching. Unexpected
+ * layouts degrade to `missing` — the safe direction, since re-running
+ * install is harmless.
+ */
+export function detectInstalledBrowsers(
+	pw: typeof import("playwright"),
+): BrowserDetection {
+	return { chromium: detectChromium(pw), firefox: detectFirefox(pw) };
+}
+
+/**
+ * Chromium detection is keyed on the headless-shell binary, not the full
+ * browser: portal launches headless, and headless launches use
+ * `chromium_headless_shell-<rev>`, not the full `chromium-<rev>` binary that
+ * `executablePath()` reports — keying on the full browser would report
+ * "downloaded" in exactly the broken-cache scenario this command fixes
+ * (full chromium present, shell missing).
+ *
+ * ponytail: the directory-name transform is a heuristic on the documented
+ * cache layout (`chromium-<rev>/` ↔ `chromium_headless_shell-<rev>/`, same
+ * parent); the shell revision comes from playwright-core's `browsers.json`,
+ * not the chromium path, so the two may safely diverge. Correctness rests on
+ * the `INSTALLATION_COMPLETE` marker (what `playwright install` writes as
+ * its final step), which is immune to inner-layout renames. If playwright
+ * renames the shell *directory*, detection degrades to "missing" (safe) —
+ * resolve the shell directory through the registry only if that misfires.
+ */
+function detectChromium(pw: typeof import("playwright")): boolean {
+	try {
+		const exec = pw.chromium.executablePath();
+		const revMatch = /([/\\])chromium-(\d+)[/\\]/.exec(exec);
+		if (!revMatch) return false;
+		let shellRev = revMatch[2];
+		try {
+			const req = createRequire(import.meta.url);
+			const coreDir = dirname(req.resolve("playwright-core/package.json"));
+			const browsers = JSON.parse(
+				readFileSync(join(coreDir, "browsers.json"), "utf8"),
+			) as { browsers: Array<{ name: string; revision: number | string }> };
+			const entry = browsers.browsers.find(
+				(b) => b.name === "chromium-headless-shell",
+			);
+			// Independent revision field from chromium's — read the shell's own,
+			// fall back to the chromium revision if the read/entry fails.
+			if (entry) shellRev = String(entry.revision);
+		} catch {
+			/* keep chromium-revision fallback */
+		}
+		const shellDir = exec.replace(
+			/([/\\])chromium-\d+[/\\].*/,
+			`$1chromium_headless_shell-${shellRev}`,
+		);
+		// replace() returning the input means the layout didn't match.
+		return (
+			shellDir !== exec && existsSync(join(shellDir, "INSTALLATION_COMPLETE"))
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Firefox has no headless-shell split — one binary. Same
+ * INSTALLATION_COMPLETE marker as chromium: a partial download that has
+ * extracted the executable but not finished would otherwise false-report
+ * "downloaded".
+ */
+function detectFirefox(pw: typeof import("playwright")): boolean {
+	try {
+		const exec = pw.firefox.executablePath();
+		const dirMatch = /[/\\]firefox-\d+[/\\]/.exec(exec);
+		if (!dirMatch) return false;
+		return existsSync(
+			join(
+				exec.slice(0, dirMatch.index + dirMatch[0].length),
+				"INSTALLATION_COMPLETE",
+			),
+		);
+	} catch {
+		return false;
+	}
+}
+
+// ─── Manual-command fallback ─────────────────────────────────────
+
+function manualCommand(bundled: BundledPlaywright, engines: Engine[]): string {
+	return `Install: ${bundled.nodeExe} ${bundled.cliJs} install ${engines.join(" ")}`;
+}
+
+function genericManualCommand(): string {
+	// Bundled path unresolvable — only the generic advice remains.
+	return "Install: npx playwright install chromium firefox";
+}
+
+/**
+ * Emit a manual-command fallback everywhere a feedback channel exists.
+ * `notify` reaches the TUI and RPC clients but is a no-op in print/JSON
+ * (their UI context is a no-op stub), where stderr is the only channel —
+ * write there too so those modes still print the command.
+ */
+function emitManualCommand(ctx: ExtensionContext, msg: string): void {
+	ctx.ui.notify(msg, "info");
+	if (!ctx.hasUI) process.stderr.write(`${msg}\n`);
+}
+
+// ─── Checklist dialog (copied from pi-lean-host select-picker.ts) ─
+//
+// pi's ctx.ui.select is single-choice and portal must not depend on host,
+// so pickChecklist is copied here. Keep the dialog rendering visually
+// identical to the host copy via the shared pickerTheme shape; the
+// behavioral deltas are intentional: an Install confirm row, pre-checked
+// rows, and an empty-selection guard (host resolves empty as []). UX
+// changes should propagate to
+// packages/pi-lean-host/core/select-picker.ts.
+
+/** Shared SelectList theme callbacks — keep both pickers visually identical. */
+function pickerTheme(theme: { fg(color: string, text: string): string }) {
+	return {
+		selectedPrefix: (text: string) => theme.fg("accent", text),
+		selectedText: (text: string) => theme.fg("accent", text),
+		description: (text: string) => theme.fg("muted", text),
+		scrollInfo: (text: string) => theme.fg("dim", text),
+		noMatch: (text: string) => theme.fg("warning", text),
+	};
+}
+
+const INSTALL_VALUE = "__install__";
+const INSTALL_TITLE = "🌐 Select browsers to install";
+
+/**
+ * Multi-select checklist: Enter toggles ✓/○, Enter on the Install row
+ * resolves the checked values, Esc returns undefined. Confirming with
+ * nothing checked notifies and keeps the dialog open. TUI-only — callers
+ * must guard with `ctx.mode === "tui"`.
+ */
+export async function pickBrowsersToInstall(
+	ctx: ExtensionContext,
+	rows: SelectItem[],
+	preChecked: string[],
+): Promise<string[] | undefined> {
+	const checked = new Set<string>(preChecked);
+	return ctx.ui.custom<string[] | undefined>((tui, theme, _kb, done) => {
+		const container = new Container();
+		let selectedIndex = 0;
+		let list = buildList();
+
+		function buildList(): SelectList {
+			const selectItems: SelectItem[] = rows.map((r) => ({
+				...r,
+				label: `${checked.has(r.value) ? "✓" : "○"} ${r.label}`,
+			}));
+			selectItems.push({
+				value: INSTALL_VALUE,
+				label: "Install — download the checked browsers",
+			});
+			const fresh = new SelectList(
+				selectItems,
+				Math.min(selectItems.length, 12),
+				pickerTheme(theme),
+			);
+			fresh.setSelectedIndex(Math.min(selectedIndex, selectItems.length - 1));
+			fresh.onSelectionChange = (item) => {
+				const at = selectItems.findIndex((s) => s.value === item.value);
+				if (at >= 0) selectedIndex = at;
+			};
+			fresh.onSelect = (item) => {
+				if (item.value === INSTALL_VALUE) {
+					if (checked.size === 0) {
+						ctx.ui.notify(
+							"Nothing selected — toggle a browser row first.",
+							"warning",
+						);
+						return;
+					}
+					done([...checked]);
+					return;
+				}
+				if (checked.has(item.value)) checked.delete(item.value);
+				else checked.add(item.value);
+				// Rebuild so the ✓/○ prefixes re-render; the highlight follows
+				// the tracked index across the swap.
+				container.removeChild(list);
+				list = buildList();
+				container.addChild(list);
+				// addChild appends — keep the footer below the rebuilt list.
+				container.removeChild(footer);
+				container.addChild(footer);
+			};
+			fresh.onCancel = () => done(undefined);
+			return fresh;
+		}
+
+		container.addChild(new Text(theme.fg("accent", theme.bold(INSTALL_TITLE))));
+		container.addChild(list);
+		const footer = new Text(
+			theme.fg("dim", "↑↓ navigate • enter toggle/select • esc cancel"),
+		);
+		container.addChild(footer);
+		return {
+			render(width: number) {
+				return container.render(width);
+			},
+			invalidate() {
+				container.invalidate();
+			},
+			handleInput(data: string) {
+				list.handleInput(data);
+				tui.requestRender();
+			},
+		};
+	});
+}
+
+// ─── Spawn & stream ──────────────────────────────────────────────
+
+/**
+ * Run the bundled playwright CLI install for the given engines, streaming
+ * output into a widget above the editor. Never throws — spawn errors and non-zero
+ * exits notify with the manual command instead.
+ */
+async function runInstall(
+	ctx: ExtensionContext,
+	bundled: BundledPlaywright,
+	engines: Engine[],
+): Promise<void> {
+	const manual = manualCommand(bundled, engines);
+	await new Promise<void>((resolve) => {
+		let out = "";
+		const child = spawn(bundled.nodeExe, [bundled.cliJs, "install", ...engines], {
+			stdio: "pipe",
+		});
+		// Bound the accumulated output: a long install must not grow memory
+		// without limit or re-split the whole buffer per chunk. The tail is
+		// enough — the host-validation warning is emitted near the end.
+		const MAX_TAIL = 64 * 1024;
+		// Show the last few download lines in a widget above the editor instead
+		// of the status bar: full progress visibility without crowding the
+		// footer. Piped (non-TTY) playwright prints a newline-terminated 10%-step
+		// progress line, so plain line splitting is enough; \r is handled for
+		// safety in case output shape changes.
+		const WIDGET_LINES = 8;
+		const tail = (chunk: Buffer) => {
+			out = (out + chunk.toString()).slice(-MAX_TAIL);
+			// ponytail: no progress-bar parsing — playwright's output format is
+			// not a stable API; the raw tail lines are enough.
+			const lines = out.trimEnd().split(/\r\n|\r|\n/);
+			ctx.ui.setWidget("install", [
+				`⬇ Installing ${engines.join(", ")}…`,
+				...lines.slice(-WIDGET_LINES).map((l) => `  ${l.trim().slice(0, 120)}`),
+			]);
+		};
+		child.stdout?.on("data", tail);
+		child.stderr?.on("data", tail);
+		// Node can fire both `error` and `close` for one failed spawn — settle
+		// once so the user gets a single notification.
+		let settled = false;
+		const finish = (notifyMsg: string, type: "info" | "warning") => {
+			if (settled) return;
+			settled = true;
+			ctx.ui.setWidget("install", undefined);
+			ctx.ui.notify(notifyMsg, type);
+			resolve();
+		};
+		child.on("error", (err) => {
+			// ENOENT, non-Node runtime with no `node` on PATH, etc.
+			finish(`Browser install failed: ${err.message}\n${manual}`, "warning");
+		});
+		child.on("close", (code) => {
+			if (code === 0) {
+				let msg = `✅ Installed: ${engines.join(", ")}`;
+				// The multi-line host-validation warning scrolls past in status
+				// text on exactly the fresh-Linux-host case where it matters —
+				// surface it in the completion notify instead. Still no
+				// --with-deps (needs root/apt): the warning names the exact
+				// install-deps command.
+				if (out.includes("Playwright Host validation warning")) {
+					msg +=
+						"\n⚠ Playwright reported missing host dependencies — run the install-deps command it printed (needs root).";
+				}
+				finish(msg, "info");
+			} else {
+				finish(`Browser install failed (exit code ${code}).\n${manual}`, "warning");
+			}
+		});
+	});
+}
+
+// ─── Handler ─────────────────────────────────────────────────────
+
+/**
+ * Handle the `/web install` subcommand.
+ *
+ * @param sub The text after "install" ("" | "chromium" | "firefox")
+ */
+export async function handleInstallSubcommand(
+	sub: string,
+	ctx: ExtensionContext,
+): Promise<void> {
+	const arg = sub.trim().toLowerCase();
+	const direct: Engine[] | null =
+		arg === "chromium" || arg === "firefox" ? [arg] : null;
+	if (arg !== "" && !direct) {
+		ctx.ui.notify(
+			`Unknown install sub-command: "${arg}". Usage: /web install [chromium|firefox]`,
+			"warning",
+		);
+		return;
+	}
+
+	// Lazy resolution — see resolveBundledPlaywright. On failure the bundled
+	// path doesn't exist to print, so only the generic command remains.
+	let bundled: BundledPlaywright;
+	try {
+		bundled = resolveBundledPlaywright();
+	} catch {
+		emitManualCommand(ctx, genericManualCommand());
+		return;
+	}
+
+	if (direct) {
+		// Direct form: spawn wherever a feedback channel exists — TUI and RPC
+		// (notify reaches the RPC client, so at least the completion message is
+		// observable); in print/JSON they're no-ops and the ~170 MB download
+		// would appear to hang, so print the manual command instead.
+		if (ctx.hasUI) {
+			await runInstall(ctx, bundled, direct);
+		} else {
+			emitManualCommand(ctx, manualCommand(bundled, direct));
+		}
+		return;
+	}
+
+	// Bare form: dialog in TUI only; every other mode (RPC included — the
+	// checklist dialog does not exist outside TUI) prints the manual command.
+	if (ctx.mode !== "tui") {
+		emitManualCommand(ctx, manualCommand(bundled, [...ENGINES]));
+		return;
+	}
+
+	// The dialog always opens, even when detection reports both downloaded:
+	// it cannot see a corrupted binary behind a valid-looking cache marker,
+	// so a forced redownload must stay reachable (downloaded rows are
+	// toggleable; missing ones come pre-checked).
+	const detection = detectInstalledBrowsers(bundled.pw);
+	const rows: SelectItem[] = ENGINES.map((engine) => ({
+		value: engine,
+		label: `${engine === "chromium" ? "Chromium" : "Firefox"} (${ENGINE_SIZES[engine]}) — ${detection[engine] ? "downloaded" : "missing"}`,
+	}));
+	const preChecked = ENGINES.filter((e) => !detection[e]);
+
+	const checked = await pickBrowsersToInstall(ctx, rows, preChecked);
+	if (checked === undefined) return; // Esc — user cancelled
+	if (checked.length === 0) return; // guarded in the dialog; defensive no-op
+	await runInstall(ctx, bundled, checked as Engine[]);
+}

package/node_modules/pi-lean-portal/browser-status.ts

@@ -10,6 +10,11 @@ import { sessionManager } from "./core/shared/session-manager.js";
 import { pluginRegistry } from "./core/plugin-registry.js";
 import { listProfiles } from "./browser-profile.js";
 import { isSessionProfile } from "./core/shared/storage-state.js";
+import {
+	ENGINES,
+	detectInstalledBrowsers,
+	resolveBundledPlaywright,
+} from "./browser-install.js";
 
 /**
  * Show detailed browser runtime status.
@@ -41,6 +46,22 @@ export function handleStatusSubcommand(
 		}
 	}
 	msg += `\nPlugins: ${backendLines.join(", ")}`;
+
+	// Browser-binary presence for the Node backends, via the same detection
+	// /web install uses. Resolution failure (corrupt install) just omits the
+	// line — /web install reports the fallback command in that case.
+	try {
+		const bundled = resolveBundledPlaywright();
+		const detected = detectInstalledBrowsers(bundled.pw);
+		const states = ENGINES.map((e) => `${e} ${detected[e] ? "✓" : "✗"}`).join(
+			" ",
+		);
+		const anyMissing = ENGINES.some((e) => !detected[e]);
+		msg += `\nBrowsers: ${states}${anyMissing ? " (run /web install)" : ""}`;
+	} catch {
+		/* playwright unresolvable — omit */
+	}
+
 	msg += `\nUse web-fetch for stateless HTTP fetches.`;
 
 	if (active.length > 0) {

package/node_modules/pi-lean-portal/browser-toggle.ts

@@ -2,7 +2,7 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { updateFooterStatus } from "./tools/utils.js";
+import { updateFooterStatus, getLastCtx, setLastCtx } from "./tools/utils.js";
 import {
 	defineToolset,
 	TOOLSET_EVENTS,
@@ -52,9 +52,6 @@ let _lastToggleState = true;
 /** @internal Last known learn state for status bar coloring. */
 let _lastLearnState = false;
 
-/** @internal Last captured ExtensionContext for event-driven status-bar rendering. */
-let _lastCtx: ExtensionContext | null = null;
-
 export function getToggleState(): boolean {
 	return _lastToggleState;
 }
@@ -105,7 +102,6 @@ function restoreProfile(_pi: ExtensionAPI, ctx: ExtensionContext): void {
 export function resetToggleModuleState(): void {
 	_lastToggleState = true;
 	_lastLearnState = false;
-	_lastCtx = null;
 	_conversationDefaultProfile = undefined;
 }
 
@@ -125,8 +121,9 @@ export default function initBrowserToggle(pi: ExtensionAPI) {
 	const syncCachedState = () => {
 		_lastToggleState = webToolset.isEnabled(pi);
 		_lastLearnState = learnToolset.isEnabled(pi);
-		if (_lastCtx) {
-			updateFooterStatus(_lastCtx);
+		const ctx = getLastCtx();
+		if (ctx) {
+			updateFooterStatus(ctx);
 		}
 	};
 
@@ -137,7 +134,7 @@ export default function initBrowserToggle(pi: ExtensionAPI) {
 	pi.registerCommand("web", {
 		description:
 			"Enable/disable browser automation tools. " +
-			"Usage: /web on | off | learn | status",
+			"Usage: /web on | off | learn | install | status",
 		handler: async (args, ctx) => {
 			const cmd = args.trim().toLowerCase();
 
@@ -187,6 +184,10 @@ export default function initBrowserToggle(pi: ExtensionAPI) {
 				const sub = cmd.slice("cookies".length).trim();
 				const { handleCookiesSubcommand } = await import("./browser-cookies.js");
 				await handleCookiesSubcommand(sub, ctx);
+			} else if (cmd === "install" || cmd.startsWith("install ")) {
+				const sub = cmd.slice("install".length).trim();
+				const { handleInstallSubcommand } = await import("./browser-install.js");
+				await handleInstallSubcommand(sub, ctx);
 			} else if (cmd === "status") {
 				const { handleStatusSubcommand } = await import("./browser-status.js");
 				handleStatusSubcommand(
@@ -203,6 +204,7 @@ export default function initBrowserToggle(pi: ExtensionAPI) {
 						`📖 Learn mode: ${learnOn}\n` +
 						`   /web profile     manage browser profiles\n` +
 						`   /web cookies     inspect or clear session cookies\n` +
+						`   /web install     install browser binaries (bundled playwright CLI)\n` +
 						`   /web off         disable all browser tools\n` +
 						`   /web on          enable browsing only\n` +
 						`   /web learn       enable browsing + guide-saving\n` +
@@ -217,17 +219,17 @@ export default function initBrowserToggle(pi: ExtensionAPI) {
 	// ── Session handlers: restore profile + render status bar ─
 	pi.on("session_start", async (_event, ctx) => {
 		restoreProfile(pi, ctx);
-		_lastCtx = ctx;
+		setLastCtx(ctx);
 		syncCachedState();
 	});
 
 	pi.on("session_tree", async (_event, ctx) => {
 		restoreProfile(pi, ctx);
-		_lastCtx = ctx;
+		setLastCtx(ctx);
 		syncCachedState();
 	});
 
 	pi.on("session_shutdown", async () => {
-		_lastCtx = null;
+		setLastCtx(null);
 	});
 }

package/node_modules/pi-lean-portal/core/fetch-backend.ts

@@ -111,8 +111,6 @@ async function performFetch(
 			redirect: "follow",
 		});
 
-		clearTimeout(timeoutId);
-
 		if (!response.ok) {
 			throw new Error(`HTTP ${response.status} ${response.statusText ?? ""}`);
 		}
@@ -128,6 +126,8 @@ async function performFetch(
 
 		return { title, needsJavaScript, root };
 	} finally {
+		// Timer stays armed through the body read, so `timeout` bounds the
+		// whole request, not just the response headers.
 		clearTimeout(timeoutId);
 	}
 }

package/node_modules/pi-lean-portal/core/router.ts

@@ -83,36 +83,6 @@ export interface NavigateOptions {
 	piSessionId?: string;
 }
 
-// ─── Profile Change Callback ───────────────────────────────────────
-
-/**
- * Simple nullable callback for profile changes.
- * Used by index.ts to update the TUI status bar.
- */
-let _onProfileChange:
-	| ((
-			taskId: string,
-			profileName?: string,
-			profileMode?: "none" | "session" | "named",
-	  ) => void)
-	| null = null;
-
-/**
- * Set the profile change callback.
- * Called once at extension startup from index.ts.
- */
-export function setOnProfileChange(
-	handler:
-		| ((
-				taskId: string,
-				profileName?: string,
-				profileMode?: "none" | "session" | "named",
-		  ) => void)
-		| null,
-): void {
-	_onProfileChange = handler;
-}
-
 // ─── Helpers ─────────────────────────────────────────────────────────
 
 /**
@@ -489,8 +459,13 @@ export async function navigate(
 		resolvedProfileName = profileInput;
 	}
 
-	// ── Notify profile change callback ─────────────────────
-	_onProfileChange?.(taskId, resolvedProfileName, profileMode);
+	// ── Notify profile change ─────────────────────
+	if (process.env.BROWSER_DEBUG) {
+		const parts = [`[browser] profile_changed: task=${taskId}`];
+		if (resolvedProfileName) parts.push(`profile=${resolvedProfileName}`);
+		if (profileMode) parts.push(`mode=${profileMode}`);
+		console.error(parts.join(" "));
+	}
 
 	// ── Create session and navigate ───────────────────────────
 	sessionManager.createSession(taskId, plugin.name);

package/node_modules/pi-lean-portal/core/shared/session-manager.ts

@@ -2,8 +2,6 @@ import { getProfileLabel } from "./storage-state.js";
 
 /**
  * Session manager — tracks browser session lifecycle per task_id.
-
-
  *
  * Design: sessions track metadata; browsers and contexts are managed
  * entirely by the plugin. The session manager is Playwright-agnostic.
@@ -112,7 +110,7 @@ class SessionManager {
 		this.#lastNav.delete(taskId);
 	}
 
-	async removeAll(): Promise<void> {
+	removeAll(): void {
 		this.#sessions.clear();
 		this.#lastNav.clear();
 	}