pi-chrome 0.15.37 → 0.15.39

package/extensions/chrome-profile-bridge/index.ts

@@ -702,6 +702,7 @@ export default function (pi: ExtensionAPI): void {
 	};
 	let chromeToolsRegistered = false;
 	let authExpiryTimer: NodeJS.Timeout | undefined;
+	let countdownInterval: NodeJS.Timeout | undefined;
 	// Remembered so bridge sends can tag tabs with this session's group even when ctx isn't handy.
 	let sessionCtx: ExtensionContext | undefined;
 
@@ -711,6 +712,12 @@ export default function (pi: ExtensionAPI): void {
 		authExpiryTimer = undefined;
 	};
 
+	const clearCountdownInterval = (): void => {
+		if (!countdownInterval) return;
+		clearInterval(countdownInterval);
+		countdownInterval = undefined;
+	};
+
 	const activeToolNamesWithoutChrome = (): string[] => pi.getActiveTools().filter((name) => !CHROME_TOOL_NAME_SET.has(name));
 
 	const activateChromeTools = (): void => {
@@ -722,11 +729,23 @@ export default function (pi: ExtensionAPI): void {
 		pi.setActiveTools(activeToolNamesWithoutChrome());
 	};
 
+	// Close THIS session's dedicated automation window/tab. Fire-and-forget and best-effort: it
+	// must never block /quit, /reload, revoke, or session end, and the service-worker side only
+	// ever closes targets this session created itself (never user tabs/windows, never another
+	// session's target). Errors (bridge down, target already closed) are intentionally swallowed.
+	const cleanupAutomationTargetBestEffort = (): void => {
+		const sessionKey = sessionKeyFor(sessionCtx);
+		void bridge.send("automation.cleanup", sessionKey !== undefined ? { sessionKey } : {}, 3_000).catch(() => undefined);
+	};
+
 	const lockChromeControl = (): void => {
 		clearAuthExpiryTimer();
+		clearCountdownInterval();
 		chromeAuthorizedUntil = undefined;
 		persistAuth();
 		deactivateChromeTools();
+		// Revoking control ends pi-chrome's automation for this session; tidy up the target we own.
+		cleanupAutomationTargetBestEffort();
 	};
 
 	const authSummary = (): string => {
@@ -759,16 +778,51 @@ export default function (pi: ExtensionAPI): void {
 		return `Pi Session: ${name || id || "unknown"}`;
 	};
 
+	const authCountdownLabel = (): string => {
+		if (chromeAuthorizedUntil === "indefinite") return " (indefinite)";
+		if (typeof chromeAuthorizedUntil === "number") {
+			const remainingMs = chromeAuthorizedUntil - Date.now();
+			if (remainingMs > 0) {
+				const mins = Math.ceil(remainingMs / 60_000);
+				return mins >= 1 ? ` (${mins}m)` : " (<1m)";
+			}
+		}
+		return "";
+	};
+
+	// Stable per-session key the service worker uses to scope its dedicated automation tab/window
+	// to *this* session (one extension brokers all sessions). The session id is stable across
+	// /reload, so the automation target is reused rather than orphaned. Returns undefined only
+	// before session_start, in which case the worker uses its default bucket.
+	const sessionKeyFor = (ctx: ExtensionContext | undefined): string | undefined => {
+		const id = ctx?.sessionManager?.getSessionId?.();
+		return typeof id === "string" && id ? `session:${id}` : undefined;
+	};
+
 	const updateChromeStatus = (ctx: ExtensionContext): void => {
 		if (chromeControlAuthorized()) {
-			ctx.ui.setStatus("chrome", ctx.ui.theme.fg("success", "●") + " Chrome Bridge");
+			ctx.ui.setStatus("chrome", ctx.ui.theme.fg("success", "●") + " Chrome Bridge" + authCountdownLabel());
 		} else {
 			ctx.ui.setStatus("chrome", undefined);
 		}
 	};
 
+	// Ticks every 60 s while a timed authorization is active to keep the countdown current.
+	const startCountdownTicker = (ctx: ExtensionContext): void => {
+		clearCountdownInterval();
+		if (chromeAuthorizedUntil === "indefinite" || typeof chromeAuthorizedUntil !== "number") return;
+		countdownInterval = setInterval(() => {
+			if (!chromeControlAuthorized()) {
+				clearCountdownInterval();
+				return;
+			}
+			updateChromeStatus(ctx);
+		}, 60_000);
+	};
+
 	const scheduleAuthExpiry = (ctx: ExtensionContext, until: number | "indefinite"): void => {
 		clearAuthExpiryTimer();
+		startCountdownTicker(ctx);
 		if (until === "indefinite") return;
 		authExpiryTimer = setTimeout(() => {
 			if (chromeAuthorizedUntil !== until) return;
@@ -784,14 +838,27 @@ export default function (pi: ExtensionAPI): void {
 
 	const authorizedBridgeSend = (action: string, params: Record<string, unknown>, timeoutMs = DEFAULT_TIMEOUT_MS, signal?: AbortSignal): Promise<unknown> => {
 		requireChromeControlAuthorized();
+		// Scope the service worker's dedicated automation tab/window to this session. Forwarded on
+		// every action so tab resolution, navigation, and cleanup all agree on which target is ours.
+		const sessionKey = sessionKeyFor(sessionCtx);
+		let wireParams: Record<string, unknown> = sessionKey !== undefined && params.sessionKey === undefined
+			? { ...params, sessionKey }
+			: params;
+		const sessionTitle = sessionCtx !== undefined ? sessionGroupTitle(sessionCtx) : undefined;
+		// Any tab Pi opens through tab.new/tab.group must use THIS session's group, even if a caller
+		// passes group:false or a custom groupTitle. This central guard covers chrome_tab plus internal
+		// callers such as chrome_launch(url).
+		if ((action === "tab.new" || action === "tab.group") && sessionTitle !== undefined) {
+			wireParams = { ...wireParams, groupTitle: sessionTitle };
+		}
 		// Any tab Pi *uses* (page.* interactions) should join this session's group, mirroring the
 		// auto-grouping that tab.new already does. Tagging the wire params lets getTabByParams pull
-		// the resolved (e.g. active) tab into the session group on the service-worker side. We skip
-		// tab.* actions: tab.new/group group explicitly, and activate/close/ungroup/list must not.
-		const shouldJoinGroup = action.startsWith("page.") && sessionCtx !== undefined && params.sessionGroupTitle === undefined;
-		const wireParams = shouldJoinGroup
-			? { ...params, sessionGroupTitle: sessionGroupTitle(sessionCtx as ExtensionContext), joinSessionGroup: true }
-			: params;
+		// the resolved tab into the session group on the service-worker side. We skip tab.* actions:
+		// tab.new/group are forced above, and activate/close/ungroup/list must not group tabs.
+		const shouldJoinGroup = action.startsWith("page.") && sessionTitle !== undefined && params.sessionGroupTitle === undefined;
+		if (shouldJoinGroup) {
+			wireParams = { ...wireParams, sessionGroupTitle: sessionTitle, joinSessionGroup: true };
+		}
 		return bridge.send(action, wireParams, timeoutMs, signal);
 	};
 
@@ -816,12 +883,22 @@ export default function (pi: ExtensionAPI): void {
 		if (chromeControlAuthorized()) {
 			activateChromeTools();
 			if (typeof chromeAuthorizedUntil === "number") scheduleAuthExpiry(ctx, chromeAuthorizedUntil);
+			else if (chromeAuthorizedUntil === "indefinite") startCountdownTicker(ctx);
 		}
 		updateChromeStatus(ctx);
 	});
 
-	pi.on("session_shutdown", () => {
+	pi.on("session_shutdown", (event) => {
 		clearAuthExpiryTimer();
+		clearCountdownInterval();
+		// Tidy up this session's dedicated automation window on real session end, but NOT on
+		// "reload": /reload tears down and re-evaluates this module while the *same* session
+		// (same sessionKey) continues, so we keep the window so it is reused, not churned. The
+		// call is fire-and-forget and runs before bridge.stop() so it never blocks shutdown.
+		// (Owner-session quit may not deliver in time since stop() closes the bridge server;
+		// that only ever leaves a clearly pi-chrome window for the user to close — never a user
+		// tab — and /chrome revoke remains the reliable, bridge-alive cleanup path.)
+		if (event?.reason !== "reload") cleanupAutomationTargetBestEffort();
 		bridge.stop();
 		if (globalState[PI_CHROME_GLOBAL_KEY]?.token === instanceToken) {
 			delete globalState[PI_CHROME_GLOBAL_KEY];
@@ -836,6 +913,11 @@ export default function (pi: ExtensionAPI): void {
 <chrome-profile-bridge>
 Chrome control is available through the chrome_* tools via a companion Chrome extension installed in the user's normal Chrome profile. Tools target the existing signed-in profile: no remote-debug port, no throwaway profile.
 
+Tab/window isolation (important):
+- pi-chrome owns a dedicated automation window/tab. When a chrome_* tool runs with no explicit target, it acts on that pi-chrome-owned target — it never reuses or overwrites the user's currently active tab. The dedicated target is created on first use and reused afterward.
+- To act on a specific *existing* tab (e.g. one the user asks you to use), pass targetId/urlIncludes/titleIncludes. Without one of those, assume you are working in pi-chrome's own automation target.
+- pi-chrome's automation target may be closed automatically when Chrome control is revoked; user tabs/windows are never closed by pi-chrome.
+
 Capability model (important):
 - Interactive controls (click/type/fill/key/hover/drag/scroll/tap) use Chrome's real input layer via chrome.debugger / CDP. Events satisfy normal user-activation gates.
 - Input bypasses page CSP because it is injected at browser input layer, not page JavaScript. Chrome may show the “Pi Chrome Connector started debugging this browser” banner while attached.
@@ -1204,7 +1286,7 @@ Usage rules:
 	pi.registerTool({
 		name: "chrome_tab",
 		label: "Chrome Tab",
-		description: "List, create, activate, close, group, ungroup, or inspect tabs in the user's existing Chrome profile via the companion extension.",
+		description: "List, create, activate, close, group, ungroup, or inspect tabs in the user's existing Chrome profile via the companion extension. New/grouped tabs always use this session's Pi tab group. activate/close/group/ungroup require a target (targetId/urlIncludes/titleIncludes); with no target they act on this session's pi-chrome automation tab if one exists, and otherwise error rather than touching the user's active tab.",
 		promptSnippet: "List/open/activate/close/group existing Chrome tabs through the companion extension.",
 		parameters: Type.Object({
 			action: StringEnum(tabActionValues),
@@ -1212,18 +1294,18 @@ Usage rules:
 			targetId: Type.Optional(Type.String({ description: "Chrome tab id for activate/close/group/ungroup." })),
 			urlIncludes: Type.Optional(Type.String({ description: "Match the target tab by URL substring for activate/close/group/ungroup." })),
 			titleIncludes: Type.Optional(Type.String({ description: "Match the target tab by title substring for activate/close/group/ungroup." })),
-			group: Type.Optional(Type.Boolean({ description: "action=new only: pass false to open an ungrouped tab. By default every Pi-opened tab joins this session's own tab group." })),
-			groupTitle: Type.Optional(Type.String({ description: "Tab group title for action=group/new. Defaults to this Pi session's group ('Pi Session: <name-or-id>'). Pass an empty string on action=new to opt out of grouping." })),
+			group: Type.Optional(Type.Boolean({ description: "Deprecated; ignored. Pi-created tabs always join this session's own tab group." })),
+			groupTitle: Type.Optional(Type.String({ description: "Deprecated for action=new/group; ignored so one Pi session uses one tab group ('Pi Session: <name-or-id>')." })),
 			groupColor: Type.Optional(Type.String({ description: "Tab group color for action=group/new: grey, blue, red, yellow, green, pink, purple, cyan, or orange. Defaults to blue." })),
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
 		async execute(_id, params, signal, _onUpdate, ctx): Promise<ToolTextResult> {
 			const forwarded = { ...params } as typeof params & { groupTitle?: string };
-			// Default every Pi-opened/explicitly-grouped tab into this session's own group,
-			// named after the session display name (falling back to the session id), unless
-			// the caller specified a group title or opted out with group:false.
-			if ((params.action === "new" || params.action === "group") && params.groupTitle === undefined && params.group !== false) {
+			// Force every Pi-opened/explicitly-grouped tab into this session's own group,
+			// named after the session display name (falling back to the session id). There is
+			// intentionally no opt-out: one Pi session should create/use one tab group.
+			if (params.action === "new" || params.action === "group") {
 				forwarded.groupTitle = sessionGroupTitle(ctx);
 			}
 			const result = await authorizedBridgeSend(`tab.${params.action}`, forwarded, DEFAULT_TIMEOUT_MS, signal);
@@ -1351,7 +1433,7 @@ Usage rules:
 		name: "chrome_navigate",
 		label: "Chrome Navigate",
 		description:
-			"Navigate an existing Chrome tab to a URL via the companion extension. Runs in the background by default; pass background=false to focus Chrome and activate the tab so the user can watch. Optionally waits for load completion.",
+			"Navigate a Chrome tab to a URL via the companion extension. With no target, navigation goes to pi-chrome's own dedicated automation window/tab — it never replaces the user's active tab. Pass targetId/urlIncludes/titleIncludes only to act on a specific existing tab. Runs in the background by default; pass background=false to focus Chrome and activate the tab so the user can watch. Optionally waits for load completion.",
 		promptSnippet: "Navigate a Chrome tab in the user's existing profile.",
 		parameters: Type.Object({
 			url: Type.String(),
@@ -1413,6 +1495,7 @@ Usage rules:
 			selector: Type.Optional(Type.String({ description: "CSS selector to click. Prefer uid from chrome_snapshot when available." })),
 			x: Type.Optional(Type.Number({ description: "Viewport x coordinate if uid/selector is omitted." })),
 			y: Type.Optional(Type.Number({ description: "Viewport y coordinate if uid/selector is omitted." })),
+			domFallback: Type.Optional(Type.Boolean({ description: "If true (default), fall back to DOM-dispatched click if Chrome's CDP input path is blocked by another extension overlay or debugger failure." })),
 			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after the click." })),
 			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
 			targetId: Type.Optional(Type.String()),
@@ -1478,6 +1561,7 @@ Usage rules:
 			uid: Type.Optional(Type.String({ description: "Stable element uid from chrome_snapshot." })),
 			selector: Type.Optional(Type.String({ description: "CSS selector to fill if uid is omitted." })),
 			submit: Type.Optional(Type.Boolean({ description: "If true, press Enter after filling." })),
+			domFallback: Type.Optional(Type.Boolean({ description: "If true (default), fall back to DOM value-setting if Chrome's CDP input path is blocked by another extension overlay or debugger failure." })),
 			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after filling." })),
 			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
 			targetId: Type.Optional(Type.String()),

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "pi-chrome",
-	"version": "0.15.37",
+	"version": "0.15.39",
 	"scripts": {
-		"test": "node test-suite/unit/csp-eval.test.mjs",
+		"test": "node test-suite/unit/csp-eval.test.mjs && node test-suite/unit/automation-target.test.mjs",
 		"version": "node scripts/sync-manifest-version.js",
 		"prepublishOnly": "node scripts/sync-manifest-version.js"
 	},

package/test-suite/unit/automation-target.test.mjs

@@ -0,0 +1,387 @@
+// Unit harness for pi-chrome's dedicated automation tab/window isolation in service_worker.js.
+//
+// Feature under test: pi-chrome must never navigate or replace the user's active tab. Page and
+// navigation actions without an explicit target are routed to a dedicated automation target that
+// the *calling Pi session* created and owns. Ownership is session-scoped (one extension brokers
+// every session) and mirrored to chrome.storage.session so a service-worker restart re-hydrates
+// it instead of orphaning the window. Cleanup closes only the calling session's owned target.
+//
+// Like csp-eval.test.mjs we load the *real* worker into a vm sandbox with a stateful chrome.*
+// mock, then exercise the real helpers and the real dispatch() paths. Chrome state (tabs/windows/
+// storage.session) can be shared across two sandbox loads to simulate a service-worker restart.
+
+import vm from "node:vm";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const workerPath = path.resolve(__dirname, "../../extensions/chrome-profile-bridge/browser-extension/service_worker.js");
+const src = fs.readFileSync(workerPath, "utf8");
+
+let failures = 0;
+let passes = 0;
+function ok(cond, msg) {
+  if (cond) { passes++; }
+  else { failures++; console.error(`  ✗ ${msg}`); }
+}
+async function throwsWith(fn, re, msg) {
+  try { await fn(); ok(false, `${msg} (expected throw)`); }
+  catch (e) { ok(re.test(String(e.message || e)), `${msg} (got: ${e.message})`); }
+}
+
+// ---- stateful Chrome mock. `state` (tabs/windows/storage) can be shared to simulate a
+// service-worker restart: the browser keeps its tabs/windows/session-storage, the worker memory
+// is wiped (a fresh sandbox).
+function makeChromeState() {
+  const tabs = new Map(); // id -> { id, windowId, url, active, groupId }
+  const windows = new Map(); // id -> { id }
+  const groups = new Map(); // groupId -> { id, title, color, collapsed, windowId }
+  const storage = {}; // chrome.storage.session backing
+  let nextTabId = 1;
+  let nextWindowId = 1;
+  let nextGroupId = 1;
+  const alloc = { tab: () => nextTabId++, window: () => nextWindowId++, group: () => nextGroupId++ };
+
+  // Seed a user window with two real user tabs (Gmail + a research article, the active one).
+  const userWindowId = alloc.window();
+  windows.set(userWindowId, { id: userWindowId });
+  const userGmail = { id: alloc.tab(), windowId: userWindowId, url: "https://mail.google.com/", active: false, groupId: -1 };
+  const userArticle = { id: alloc.tab(), windowId: userWindowId, url: "https://example.com/research-article", active: true, groupId: -1 };
+  tabs.set(userGmail.id, userGmail);
+  tabs.set(userArticle.id, userArticle);
+
+  return { tabs, windows, groups, storage, alloc, userWindowId, userGmail, userArticle };
+}
+
+function makeChrome(state, { withWindows = true, withStorage = true, withTabGroups = false } = {}) {
+  const { tabs, windows, groups, storage, alloc, userWindowId } = state;
+  const noop = () => {};
+  const listener = { addListener: noop, removeListener: noop };
+
+  const chrome = {
+    runtime: { id: "unittestextension", getManifest: () => ({ version: "0.0.0" }), onInstalled: listener, onStartup: listener, lastError: null },
+    alarms: { onAlarm: listener, create: noop, clear: noop, clearAll: noop },
+    action: { onClicked: listener },
+    debugger: { sendCommand: noop, attach: async () => {}, detach: async () => {}, getTargets: (cb) => cb([]), onDetach: listener },
+    scripting: { executeScript: async () => [{ result: undefined }], registerContentScripts: async () => {}, unregisterContentScripts: async () => {} },
+    webNavigation: { onCommitted: listener },
+    tabs: {
+      onUpdated: listener,
+      query: async (q = {}) => {
+        let list = [...tabs.values()];
+        if (q.active === true) list = list.filter((t) => t.active);
+        if (typeof q.windowId === "number") list = list.filter((t) => t.windowId === q.windowId);
+        return list.map((t) => ({ ...t }));
+      },
+      get: async (id) => { const t = tabs.get(id); if (!t) throw new Error(`No tab with id ${id}`); return { ...t }; },
+      create: async ({ url = "about:blank", active = false, windowId = userWindowId } = {}) => {
+        const tab = { id: alloc.tab(), windowId, url, active, groupId: -1 };
+        tabs.set(tab.id, tab);
+        return { ...tab };
+      },
+      update: async (id, props = {}) => { const t = tabs.get(id); if (!t) throw new Error(`No tab with id ${id}`); Object.assign(t, props); return { ...t }; },
+      remove: async (id) => { tabs.delete(id); },
+      group: async ({ groupId, tabIds = [] } = {}) => {
+        let gid = groupId;
+        if (typeof gid !== "number") {
+          gid = alloc.group();
+          const firstTab = tabs.get(tabIds[0]);
+          groups.set(gid, { id: gid, title: "", color: "grey", collapsed: false, windowId: firstTab ? firstTab.windowId : userWindowId });
+        }
+        for (const tid of tabIds) { const t = tabs.get(tid); if (t) t.groupId = gid; }
+        return gid;
+      },
+      ungroup: async (id) => { const ids = Array.isArray(id) ? id : [id]; for (const tid of ids) { const t = tabs.get(tid); if (t) t.groupId = -1; } },
+    },
+    storage: withStorage ? {
+      session: {
+        get: async (key) => (key in storage ? { [key]: storage[key] } : {}),
+        set: async (obj) => { Object.assign(storage, obj); },
+      },
+    } : undefined,
+  };
+
+  if (withTabGroups) {
+    chrome.tabGroups = {
+      query: async ({ windowId } = {}) => [...groups.values()].filter((g) => windowId === undefined || g.windowId === windowId).map((g) => ({ ...g })),
+      get: async (id) => { const g = groups.get(id); if (!g) throw new Error(`No group ${id}`); return { ...g }; },
+      update: async (id, props = {}) => { const g = groups.get(id); if (!g) throw new Error(`No group ${id}`); Object.assign(g, props); return { ...g }; },
+    };
+  }
+
+  if (withWindows) {
+    chrome.windows = {
+      create: async ({ url = "about:blank", focused = false } = {}) => {
+        const id = alloc.window();
+        windows.set(id, { id });
+        const tab = { id: alloc.tab(), windowId: id, url, active: true, groupId: -1 };
+        tabs.set(tab.id, tab);
+        return { id, focused, tabs: [{ ...tab }] };
+      },
+      get: async (id) => { const w = windows.get(id); if (!w) throw new Error(`No window with id ${id}`); return { ...w }; },
+      remove: async (id) => { windows.delete(id); for (const [tid, t] of [...tabs]) if (t.windowId === id) tabs.delete(tid); },
+      update: async () => {},
+    };
+  } else {
+    chrome.windows = { update: async () => {} }; // no create/get/remove -> tab fallback path
+  }
+
+  return chrome;
+}
+
+function loadWorker(chrome) {
+  const noop = () => {};
+  const sandbox = {
+    console, JSON, Date, Math, Promise, Array, Object, String, Number, Boolean,
+    Error, TypeError, Map, Set, BigInt, Symbol, structuredClone,
+    setTimeout, clearTimeout, setInterval: () => 0, clearInterval: noop,
+    fetch: async () => { throw new Error("no network in unit test"); },
+    navigator: { userAgent: "unit-test" },
+    WebSocket: function () {},
+    chrome,
+  };
+  sandbox.globalThis = sandbox;
+  sandbox.self = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(src, sandbox);
+  return sandbox;
+}
+
+const SK = "session:alpha"; // a representative sessionKey
+
+async function run() {
+  // ===== Isolation: navigation does not touch the user's active/other tabs. =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state));
+    const userActiveUrl = state.userArticle.url;
+
+    const nav = await w.dispatch("page.navigate", { url: "https://pi.test/task", waitUntilLoad: false, sessionKey: SK });
+    ok(state.userArticle.url === userActiveUrl, "navigate: active user tab (research article) is not overwritten");
+    ok(state.userGmail.url === "https://mail.google.com/", "navigate: other user tab (Gmail) untouched");
+    ok(nav.url === "https://pi.test/task", "navigate: automation target navigated to requested URL");
+    ok(nav.id !== state.userArticle.id && nav.id !== state.userGmail.id, "navigate: did not reuse any user tab");
+    ok(nav.windowId !== state.userWindowId, "navigate: automation target lives in a dedicated window");
+
+    const status = await w.dispatch("automation.status", { sessionKey: SK });
+    ok(status.tabId === nav.id && status.windowId === nav.windowId, "ownership: target ids tracked for the session");
+    ok(w.isPiChromeOwnedTarget(nav.id, SK) === true, "ownership: isPiChromeOwnedTarget(owned, session) === true");
+    ok(w.isPiChromeOwnedTarget(state.userArticle.id) === false, "ownership: user tab is never owned (any session)");
+
+    // Reuse: a later navigation reuses the same owned target.
+    const nav2 = await w.dispatch("page.navigate", { url: "https://pi.test/step-2", waitUntilLoad: false, sessionKey: SK });
+    ok(nav2.id === nav.id && nav2.windowId === nav.windowId, "reuse: second navigation reuses the same automation window/tab");
+    ok(state.userArticle.url === userActiveUrl, "reuse: user tab still untouched after second navigation");
+
+    // Cleanup closes only the owned window; user tabs/windows survive.
+    const cleanup = await w.dispatch("automation.cleanup", { sessionKey: SK });
+    ok(cleanup.closedWindowId === nav.windowId, "cleanup: closed the owned window");
+    ok(state.tabs.has(state.userArticle.id) && state.tabs.has(state.userGmail.id), "cleanup: user tabs never closed");
+    ok(state.windows.has(state.userWindowId), "cleanup: user window never closed");
+    ok(!state.tabs.has(nav.id), "cleanup: the owned automation tab is gone");
+    const status2 = await w.dispatch("automation.status", { sessionKey: SK });
+    ok(status2.tabId === null && status2.windowId === null, "cleanup: ownership cleared");
+  }
+
+  // ===== Session-group integration: the dedicated-window tab joins this session's group. =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state, { withTabGroups: true }));
+    // index.ts tags page.* actions with joinSessionGroup + sessionGroupTitle; replicate that here.
+    const groupTitle = "Pi Session: alpha";
+    const nav = await w.dispatch("page.navigate", {
+      url: "https://pi.test/grouped", waitUntilLoad: false,
+      sessionKey: SK, joinSessionGroup: true, sessionGroupTitle: groupTitle,
+    });
+    const navTab = state.tabs.get(nav.id);
+    ok(navTab.windowId !== state.userWindowId, "group: automation tab is in its dedicated window");
+    ok(typeof navTab.groupId === "number" && navTab.groupId >= 0, "group: automation tab joined a tab group");
+    const grp = state.groups.get(navTab.groupId);
+    ok(grp && grp.title === groupTitle, "group: the group is titled with this session's title");
+    ok(grp.windowId === navTab.windowId, "group: the session group lives inside the dedicated automation window (not the user window)");
+
+    // A second page action reuses the same tab and does not spawn a second group.
+    const groupsBefore = state.groups.size;
+    await w.dispatch("page.navigate", { url: "https://pi.test/grouped-2", waitUntilLoad: false, sessionKey: SK, joinSessionGroup: true, sessionGroupTitle: groupTitle });
+    ok(state.groups.size === groupsBefore, "group: reusing the automation tab does not create a second group");
+  }
+
+  // ===== tab.new joins the existing session group instead of creating one group per window. =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state, { withTabGroups: true }));
+    const groupTitle = "Pi Session: alpha";
+    const nav = await w.dispatch("page.navigate", {
+      url: "https://pi.test/group-owner", waitUntilLoad: false,
+      sessionKey: SK, joinSessionGroup: true, sessionGroupTitle: groupTitle,
+    });
+    const navTab = state.tabs.get(nav.id);
+    const groupId = navTab.groupId;
+    const groupsBefore = state.groups.size;
+
+    const opened = await w.dispatch("tab.new", { url: "https://pi.test/new-tab", groupTitle, sessionKey: SK });
+    ok(state.groups.size === groupsBefore, "tab.new-group: did not create another same-session group");
+    ok(opened.tab.groupId === groupId, "tab.new-group: opened tab joined the existing session group");
+    ok(opened.tab.windowId === nav.windowId, "tab.new-group: opened tab was created in the existing group's window");
+
+    const forced = await w.dispatch("tab.new", { url: "https://pi.test/no-opt-out", groupTitle, group: false, sessionKey: SK });
+    ok(forced.tab.groupId === groupId, "tab.new-group: group:false is ignored; tab still joins the session group");
+    ok(state.groups.size === groupsBefore, "tab.new-group: group:false does not create another group");
+
+    const blankTitle = await w.dispatch("tab.new", { url: "https://pi.test/blank-title", groupTitle: "", group: false, sessionKey: SK });
+    ok(typeof blankTitle.tab.groupId === "number" && blankTitle.tab.groupId >= 0, "tab.new-group: groupTitle:'' still creates a grouped tab");
+    ok(blankTitle.group.title === "Pi", "tab.new-group: blank groupTitle falls back to a group instead of opting out");
+  }
+
+  // ===== tab.new never leaves an ungrouped tab behind when grouping fails. =====
+  {
+    const state = makeChromeState();
+    const chrome = makeChrome(state, { withTabGroups: true });
+    const w = loadWorker(chrome);
+    const tabsBefore = state.tabs.size;
+    chrome.tabs.group = async () => { throw new Error("group blew up"); };
+
+    await throwsWith(
+      () => w.dispatch("tab.new", { url: "https://pi.test/group-fail", groupTitle: "Pi Session: alpha", sessionKey: SK }),
+      /group blew up/,
+      "tab.new-group-fail: surfaces grouping error",
+    );
+    ok(state.tabs.size === tabsBefore, "tab.new-group-fail: closes the created tab instead of leaving it ungrouped");
+  }
+
+  // ===== Grouping is best-effort: a tabGroups failure must not break navigation. =====
+  {
+    const state = makeChromeState();
+    const chrome = makeChrome(state, { withTabGroups: true });
+    chrome.tabs.group = async () => { throw new Error("group blew up"); };
+    const w = loadWorker(chrome);
+    const nav = await w.dispatch("page.navigate", { url: "https://pi.test/group-fail", waitUntilLoad: false, sessionKey: SK, joinSessionGroup: true, sessionGroupTitle: "Pi Session: alpha" });
+    ok(nav.url === "https://pi.test/group-fail", "group-fail: navigation still succeeds when grouping throws");
+    ok(state.tabs.get(nav.id).windowId !== state.userWindowId, "group-fail: still used the dedicated automation window");
+  }
+
+  // ===== Concurrency: two sessions get separate windows; cleanup is per-session. =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state));
+    const a = await w.dispatch("page.navigate", { url: "https://pi.test/a", waitUntilLoad: false, sessionKey: "session:A" });
+    const b = await w.dispatch("page.navigate", { url: "https://pi.test/b", waitUntilLoad: false, sessionKey: "session:B" });
+    ok(a.id !== b.id && a.windowId !== b.windowId, "concurrency: each session gets its own dedicated window/tab");
+    ok(w.isPiChromeOwnedTarget(a.id, "session:A") && !w.isPiChromeOwnedTarget(a.id, "session:B"), "concurrency: ownership is scoped to the creating session");
+
+    // Cleaning up session A must not touch session B's target.
+    await w.dispatch("automation.cleanup", { sessionKey: "session:A" });
+    ok(!state.tabs.has(a.id), "concurrency: cleanup closed session A's tab");
+    ok(state.tabs.has(b.id), "concurrency: cleanup left session B's tab open");
+    const bStatus = await w.dispatch("automation.status", { sessionKey: "session:B" });
+    ok(bStatus.tabId === b.id, "concurrency: session B still owns its target after A cleanup");
+  }
+
+  // ===== Service-worker restart / reconnect: persisted ownership re-hydrates from storage. =====
+  {
+    const state = makeChromeState();
+    const w1 = loadWorker(makeChrome(state));
+    const nav = await w1.dispatch("page.navigate", { url: "https://pi.test/persist", waitUntilLoad: false, sessionKey: SK });
+    ok(typeof state.storage.piChromeAutomationTargets === "object", "restart: ownership was persisted to storage.session");
+
+    // Simulate the MV3 service worker being suspended and restarted: fresh sandbox (memory wiped),
+    // same browser tabs/windows + same session storage.
+    const w2 = loadWorker(makeChrome(state));
+    const statusAfterRestart = await w2.dispatch("automation.status", { sessionKey: SK });
+    ok(statusAfterRestart.tabId === nav.id && statusAfterRestart.windowId === nav.windowId, "restart: re-hydrated the owned target from storage");
+
+    // A navigation after restart must REUSE the existing window, not orphan it with a new one.
+    const windowsBefore = state.windows.size;
+    const nav2 = await w2.dispatch("page.navigate", { url: "https://pi.test/persist-2", waitUntilLoad: false, sessionKey: SK });
+    ok(nav2.id === nav.id && nav2.windowId === nav.windowId, "restart: navigation after restart reuses the persisted window (no orphan)");
+    ok(state.windows.size === windowsBefore, "restart: no new window created after restart");
+
+    // Cleanup after restart works and clears persisted state.
+    await w2.dispatch("automation.cleanup", { sessionKey: SK });
+    const persisted = state.storage.piChromeAutomationTargets || {};
+    ok(!(SK in persisted), "restart: cleanup removed the session from persisted storage");
+  }
+
+  // ===== Restart after the user manually closed the window: no orphan, fresh target. =====
+  {
+    const state = makeChromeState();
+    const w1 = loadWorker(makeChrome(state));
+    const nav = await w1.dispatch("page.navigate", { url: "https://pi.test/closed", waitUntilLoad: false, sessionKey: SK });
+    await state.windows.delete(nav.windowId); // user closed pi-chrome's window
+    for (const [tid, t] of [...state.tabs]) if (t.windowId === nav.windowId) state.tabs.delete(tid);
+
+    const w2 = loadWorker(makeChrome(state)); // SW restart
+    const nav2 = await w2.dispatch("page.navigate", { url: "https://pi.test/reopened", waitUntilLoad: false, sessionKey: SK });
+    ok(nav2.id !== nav.id, "restart-after-close: a fresh automation target is created when the persisted one is gone");
+    ok(state.tabs.has(nav2.id), "restart-after-close: new target exists");
+  }
+
+  // ===== tab.* management never auto-creates / never falls back to the user's active tab. =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state));
+    const windowsBefore = state.windows.size;
+    const tabsBefore = state.tabs.size;
+
+    await throwsWith(
+      () => w.dispatch("tab.close", { sessionKey: SK }),
+      /no automation tab yet|Pass targetId/,
+      "tab.close: with no target and no owned target, errors instead of closing the user's active tab",
+    );
+    ok(state.tabs.has(state.userArticle.id), "tab.close: user's active tab was NOT closed");
+    ok(state.windows.size === windowsBefore && state.tabs.size === tabsBefore, "tab.close: did not spawn a throwaway tab/window");
+
+    await throwsWith(() => w.dispatch("tab.activate", { sessionKey: SK }), /no automation tab yet|Pass targetId/, "tab.activate: errors with no target/owned target");
+
+    // Once an automation target exists, management actions operate on it (not on the user tab).
+    const nav = await w.dispatch("page.navigate", { url: "https://pi.test/manage", waitUntilLoad: false, sessionKey: SK });
+    const closed = await w.dispatch("tab.close", { sessionKey: SK });
+    ok(closed.closed === nav.id, "tab.close: with an owned target, closes that target");
+    ok(state.tabs.has(state.userArticle.id), "tab.close: user tab still safe after closing the owned target");
+  }
+
+  // ===== Explicit targeting still works on any existing tab (no regression). =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state));
+    const nav = await w.dispatch("page.navigate", { url: "https://pi.test/explicit", targetId: String(state.userGmail.id), waitUntilLoad: false, sessionKey: SK });
+    ok(nav.id === state.userGmail.id, "explicit: targetId routes to the requested existing tab");
+    ok(state.userGmail.url === "https://pi.test/explicit", "explicit: explicitly targeted tab is navigated");
+    const status = await w.dispatch("automation.status", { sessionKey: SK });
+    ok(status.tabId === null, "explicit: explicit targeting does not create/claim an automation target");
+  }
+
+  // ===== Window-unavailable fallback: a dedicated TAB is used, and the user's window is safe. =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state, { withWindows: false }));
+    const target = await w.getOrCreateAutomationTarget(SK);
+    ok(target.id !== state.userArticle.id && target.id !== state.userGmail.id, "fallback: created a dedicated tab, not a user tab");
+    ok(w.isPiChromeOwnedTarget(target.id, SK) === true, "fallback: dedicated tab is owned");
+    const cleanup = await w.cleanupAutomationTarget(SK);
+    ok(cleanup.closedTabId === target.id && cleanup.closedWindowId === null, "fallback: cleanup closes only the owned tab (never the shared window)");
+    ok(state.windows.has(state.userWindowId), "fallback: cleanup never closes the user/shared window");
+    ok(state.tabs.has(state.userArticle.id) && state.tabs.has(state.userGmail.id), "fallback: cleanup leaves user tabs intact");
+  }
+
+  // ===== Robust cleanup: no-op when nothing created, and when target already closed manually. =====
+  {
+    const state = makeChromeState();
+    const w = loadWorker(makeChrome(state));
+    const empty = await w.cleanupAutomationTarget(SK);
+    ok(empty.closedWindowId === null && empty.closedTabId === null, "cleanup: no-op when nothing was ever created");
+
+    const t = await w.getOrCreateAutomationTarget(SK);
+    // User closed pi-chrome's window manually (Chrome closes its tabs too).
+    state.windows.delete(t.windowId);
+    for (const [tid, tab] of [...state.tabs]) if (tab.windowId === t.windowId) state.tabs.delete(tid);
+    const stale = await w.cleanupAutomationTarget(SK);
+    ok(stale.closedWindowId === null && stale.closedTabId === null, "cleanup: robust when owned window was already closed");
+  }
+
+  console.log(`\n${passes} passed, ${failures} failed`);
+  if (failures) process.exit(1);
+}
+
+run().catch((e) => { console.error(e); process.exit(1); });