pi-browser-harness 0.8.3 → 0.10.0

package/src/domains/readpage/read-page.ts

@@ -0,0 +1,119 @@
+import { Type } from "typebox";
+import { type Result, err, ok } from "../../util/result";
+import { applyTruncation } from "../../util/truncate";
+import { defineBrowserTool, type ToolErr, type ToolOk } from "../../util/tool";
+import {
+  closeIsolatedTab,
+  evalInIsolatedTab,
+  type IsolatedTab,
+  navigateIsolatedTab,
+  openIsolatedTab,
+  waitForIsolatedLoad,
+} from "../isolated-tab";
+import { renderExpandableText } from "../render";
+import { buildPageCaptureExpr } from "./capture";
+import { extractReadable, type PageCapture, type ReadablePage } from "./readability";
+
+const LOAD_TIMEOUT_MS = 15_000;
+
+const ReadPageArgs = Type.Object({
+  url: Type.Optional(Type.String({ description: "URL to open in an isolated tab, read, then close." })),
+  targetId: Type.Optional(
+    Type.String({ description: "Read an already-open tab this session owns instead of opening a URL." }),
+  ),
+});
+
+const isPageCapture = (value: unknown): value is PageCapture => {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  return typeof v["url"] === "string" && typeof v["title"] === "string" && Array.isArray(v["blocks"]) && typeof v["bodyText"] === "string";
+};
+
+const safeParse = (text: string): unknown => {
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return undefined;
+  }
+};
+
+const captureToResult = async (raw: unknown): Promise<Result<ToolOk, ToolErr>> => {
+  const parsed = typeof raw === "string" ? safeParse(raw) : raw;
+  if (!isPageCapture(parsed)) return err({ kind: "internal", message: "page capture returned an unexpected shape" });
+  const page: ReadablePage = extractReadable(parsed);
+  const header = `# ${page.title}\n${page.url}\n(${page.wordCount} words)\n\n`;
+  const truncated = await applyTruncation(header + page.text, "readpage");
+  const summary = `${page.title} · ${page.wordCount} words`;
+  return ok({
+    text: truncated.text,
+    details: {
+      title: page.title,
+      url: page.url,
+      wordCount: page.wordCount,
+      render: {
+        summary,
+        body: page.text,
+        ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+      },
+      ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+    },
+  });
+};
+
+const readOpenedUrl = async (
+  client: Parameters<typeof openIsolatedTab>[0],
+  url: string,
+  signal: AbortSignal | undefined,
+): Promise<Result<ToolOk, ToolErr>> => {
+  const opened = await openIsolatedTab(client);
+  if (!opened.success) return err(opened.error);
+  const tab: IsolatedTab = opened.data;
+  try {
+    const navigated = await navigateIsolatedTab(client, tab, url);
+    if (!navigated.success) return err(navigated.error);
+    const loaded = await waitForIsolatedLoad(client, tab, LOAD_TIMEOUT_MS, signal);
+    if (!loaded.success) return err(loaded.error);
+    const captured = await evalInIsolatedTab(client, tab, buildPageCaptureExpr());
+    if (!captured.success) return err(captured.error);
+    return captureToResult(captured.data);
+  } finally {
+    await closeIsolatedTab(client, tab);
+  }
+};
+
+const readOwnedTab = async (
+  client: Parameters<typeof openIsolatedTab>[0],
+  targetId: string,
+): Promise<Result<ToolOk, ToolErr>> => {
+  if (!client.owns(targetId)) {
+    return err({ kind: "invalid_state", message: `Tab ${targetId} is not owned by this session.` });
+  }
+  const attached = await client.session().callBrowser("Target.attachToTarget", { targetId, flatten: true });
+  if (!attached.success) return err({ kind: "cdp_error", message: attached.error.message });
+  const sessionId = (attached.data as { sessionId: string }).sessionId;
+  const captured = await client.evaluateJs(buildPageCaptureExpr(), sessionId);
+  if (!captured.success) return err({ kind: "cdp_error", message: captured.error.message });
+  return captureToResult(captured.data);
+};
+
+export const readPageTool = defineBrowserTool({
+  name: "browser_read_page",
+  label: "Browser Read Page",
+  description:
+    "Read a page as clean article text — main content with nav/ads/boilerplate stripped. Pass a url (opened in an isolated tab, read, then closed) or a targetId of an owned tab. Reader-mode counterpart to browser_web_search.",
+  promptSnippet: "Read a page's main content as clean text",
+  promptGuidelines: [
+    "Pass url to read an arbitrary page (opened + closed in its own tab, never disturbing your current tab), or targetId to read an already-open owned tab.",
+    "Returns readable main-article text — use this over browser_snapshot/browser_execute_js when you want an article's content for reading or research.",
+    "Boilerplate-heavy or structure-less pages fall back to bounded body text rather than erroring.",
+  ],
+  parameters: ReadPageArgs,
+  async handler(args, { client, signal }): Promise<Result<ToolOk, ToolErr>> {
+    if (args.url !== undefined && args.url.length > 0) return readOpenedUrl(client, args.url, signal);
+    if (args.targetId !== undefined && args.targetId.length > 0) return readOwnedTab(client, args.targetId);
+    return err({ kind: "invalid_state", message: "provide either url or targetId" });
+  },
+  renderResult(result, expanded, theme) {
+    return renderExpandableText("read_page", result, expanded, theme);
+  },
+});

package/src/domains/readpage/readability.ts

@@ -0,0 +1,89 @@
+/**
+ * Pure reader-mode extraction — no CDP, no DOM. The in-page script
+ * (see capture.ts) serializes candidate content blocks; these pure functions
+ * score them and assemble clean article text, so the selection logic is
+ * unit-testable against saved fixtures (test/deep-research/readability-test.ts).
+ *
+ * Dependency-free by design (no jsdom / Readability): the harness ships no new
+ * runtime deps. The heuristic favors blocks with high text density and low link
+ * density, which is what separates article body from nav/ads/boilerplate.
+ */
+
+/** One candidate content block captured in-page. */
+export type ContentBlock = {
+  /** Semantic tag: paragraph | heading | listitem | blockquote | other. */
+  readonly kind: "paragraph" | "heading" | "listitem" | "blockquote" | "other";
+  readonly text: string;
+  /** Chars of text that sit inside <a> tags — high ratio ⇒ nav/menu, not prose. */
+  readonly linkTextLength: number;
+  /** True when an ancestor is nav/header/footer/aside — structural boilerplate. */
+  readonly inBoilerplate: boolean;
+};
+
+/** The JSON payload capture.ts returns from the page. */
+export type PageCapture = {
+  readonly url: string;
+  readonly title: string;
+  readonly blocks: ReadonlyArray<ContentBlock>;
+  /** Bounded innerText fallback when block extraction finds nothing usable. */
+  readonly bodyText: string;
+};
+
+/** The tool's public output shape. */
+export type ReadablePage = {
+  readonly title: string;
+  readonly url: string;
+  readonly text: string;
+  readonly wordCount: number;
+};
+
+const MIN_PARAGRAPH_CHARS = 25;
+const MAX_LINK_DENSITY = 0.5;
+const MIN_ARTICLE_WORDS = 40;
+
+const linkDensity = (block: ContentBlock): number => {
+  if (block.text.length === 0) return 1;
+  return block.linkTextLength / block.text.length;
+};
+
+/** A block is article prose if it is substantive, text-dense, and not chrome. */
+const isArticleBlock = (block: ContentBlock): boolean => {
+  if (block.inBoilerplate) return false;
+  if (linkDensity(block) > MAX_LINK_DENSITY) return false;
+  if (block.kind === "heading" || block.kind === "blockquote" || block.kind === "listitem") {
+    return block.text.trim().length > 0;
+  }
+  return block.text.trim().length >= MIN_PARAGRAPH_CHARS;
+};
+
+const render = (block: ContentBlock): string => {
+  const text = block.text.trim();
+  if (block.kind === "heading") return `\n## ${text}\n`;
+  if (block.kind === "listitem") return `- ${text}`;
+  if (block.kind === "blockquote") return `> ${text}`;
+  return text;
+};
+
+const wordCountOf = (text: string): number => {
+  const trimmed = text.trim();
+  return trimmed.length === 0 ? 0 : trimmed.split(/\s+/).length;
+};
+
+/**
+ * Assemble readable article text from a page capture. Keeps text-dense,
+ * non-boilerplate blocks; falls back to the bounded body text when the article
+ * is too thin (e.g. a page with no clear content structure).
+ */
+export const extractReadable = (capture: PageCapture): ReadablePage => {
+  const articleText = capture.blocks.filter(isArticleBlock).map(render).join("\n\n").replace(/\n{3,}/g, "\n\n").trim();
+
+  const useFallback = wordCountOf(articleText) < MIN_ARTICLE_WORDS;
+  const text = useFallback ? capture.bodyText.trim() : articleText;
+
+  return {
+    title: capture.title.trim(),
+    url: capture.url,
+    text,
+    wordCount: wordCountOf(text),
+  };
+};

package/src/domains/render.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared TUI renderer for text-heavy tool output (browser_web_search,
+ * browser_read_page). Gives the native pi expand/collapse (Ctrl+O) behavior:
+ * a compact preview by default, the full body when expanded — mirroring the
+ * pattern in browser_execute_js (src/domains/js.ts:81-109).
+ *
+ * The full text always goes to the LLM via ToolOk.text; this only governs the
+ * human-facing TUI view.
+ */
+import { Markdown, Text } from "@mariozechner/pi-tui";
+import { getMarkdownTheme, keyHint } from "@mariozechner/pi-coding-agent";
+import type { Component } from "@mariozechner/pi-tui";
+import type { Theme } from "@mariozechner/pi-coding-agent";
+
+const COMPACT_PREVIEW_LINES = 6;
+
+/** Structured payload a text-heavy tool stores so renderResult can rebuild views. */
+export type ExpandableText = {
+  /** One-line summary shown above the body in both states (e.g. "5 results · google"). */
+  readonly summary: string;
+  /** The full rendered body (markdown/plain). */
+  readonly body: string;
+  /** Path to the on-disk full output when the LLM text was truncated, if any. */
+  readonly fullOutputPath?: string;
+};
+
+const isExpandableText = (value: unknown): value is ExpandableText => {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  return typeof v["summary"] === "string" && typeof v["body"] === "string";
+};
+
+const extractRender = (details: unknown): unknown => {
+  if (typeof details !== "object" || details === null) return undefined;
+  return (details as Record<string, unknown>)["render"];
+};
+
+/**
+ * Build a renderResult over an ExpandableText stored in `details.render`.
+ * `label` names the tool for the error fallback (e.g. "web_search").
+ */
+export const renderExpandableText = (
+  label: string,
+  result: { readonly details?: unknown },
+  expanded: boolean,
+  theme: Theme,
+): Component => {
+  const render = extractRender(result.details);
+  if (!isExpandableText(render)) return new Text(theme.fg("error", `${label}: no details`), 0, 0);
+
+  if (!expanded) {
+    const lines = render.body.split("\n");
+    const preview = lines.slice(0, COMPACT_PREVIEW_LINES).join("\n");
+    const more = lines.length > COMPACT_PREVIEW_LINES ? `\n… ${lines.length - COMPACT_PREVIEW_LINES} more lines` : "";
+    const md = `**${render.summary}**\n\n${preview}${more}\n\n${keyHint("app.tools.expand", "to expand")}`;
+    return new Markdown(md, 0, 0, getMarkdownTheme());
+  }
+
+  const tail = render.fullOutputPath
+    ? `\n\nFull output at \`${render.fullOutputPath}\` · ${keyHint("app.tools.expand", "to collapse")}`
+    : `\n\n${keyHint("app.tools.expand", "to collapse")}`;
+  const md = `**${render.summary}**\n\n${render.body}${tail}`;
+  return new Markdown(md, 0, 0, getMarkdownTheme());
+};

package/src/domains/search/extract.ts

@@ -0,0 +1,44 @@
+/**
+ * The JavaScript source evaluated inside the Google SERP page to capture raw
+ * anchors + page text. This string crosses the CDP boundary via
+ * Runtime.evaluate (returnByValue) and returns a JSON string that
+ * `parseGoogleSerp` / `classifySerp` consume on the harness side.
+ *
+ * ADR-0001: anchors are selected structurally (a link carrying an <h3>), not by
+ * Google CSS class names, so cosmetic markup churn does not break extraction.
+ */
+
+/** Max bytes of page text captured for CAPTCHA / no-results classification. */
+const PAGE_TEXT_LIMIT = 4000;
+
+/**
+ * Build the extraction expression. Takes no interpolated values, so it is a
+ * fixed source string (no injection surface). Returns
+ * `JSON.stringify({ anchors, pageText })`.
+ */
+export const buildSerpExtractionExpr = (): string => `
+  (() => {
+    const main = document.querySelector('#search, #rso, #main') || document.body;
+    const headings = Array.from(main.querySelectorAll('a h3'));
+    const seen = new Set();
+    const anchors = [];
+    for (const h3 of headings) {
+      const a = h3.closest('a[href]');
+      if (!a) continue;
+      const href = a.href;
+      if (!href || seen.has(href)) continue;
+      seen.add(href);
+      const container =
+        a.closest('div.g') ||
+        a.closest('div[data-hveid]') ||
+        a.parentElement?.parentElement ||
+        a.parentElement;
+      const containerText = container ? container.innerText || '' : '';
+      const heading = h3.innerText || h3.textContent || '';
+      const snippet = containerText.replace(heading, '').replace(/\\s+/g, ' ').trim().slice(0, 500);
+      anchors.push({ href, heading, snippet });
+    }
+    const pageText = (document.body.innerText || '').slice(0, ${PAGE_TEXT_LIMIT});
+    return JSON.stringify({ anchors, pageText });
+  })()
+`;

package/src/domains/search/google-serp.ts

@@ -0,0 +1,114 @@
+/**
+ * Pure Google SERP parsing — no CDP, no browser. Everything here is a pure
+ * function over data captured from the page, so it is unit-testable against
+ * saved fixtures (see test/deep-research/serp-parser-test.ts).
+ *
+ * ADR-0001: results are extracted by structure/semantics (anchors carrying an
+ * <h3> heading in the main results column), never by brittle Google CSS class
+ * names, and Google redirect wrappers are unwound to the real target URL.
+ */
+
+/** One raw anchor captured in-page: a link with a heading and nearby snippet. */
+export type SerpAnchor = {
+  readonly href: string;
+  readonly heading: string;
+  readonly snippet: string;
+};
+
+/** The JSON payload the in-page extraction expression returns. */
+export type SerpExtraction = {
+  readonly anchors: ReadonlyArray<SerpAnchor>;
+  readonly pageText: string;
+};
+
+/** A parsed, ranked search result — the tool's public output shape. */
+export type SearchResult = {
+  readonly title: string;
+  readonly url: string;
+  readonly snippet: string;
+  readonly rank: number;
+};
+
+/** Why a SERP yielded no usable results, or that it did. */
+export type SerpVerdict = "ok" | "captcha" | "no_results";
+
+const CAPTCHA_MARKERS: ReadonlyArray<string> = [
+  "unusual traffic",
+  "not a robot",
+  "recaptcha",
+  "detected unusual",
+  "systems have detected",
+  "before you continue to google",
+  "our systems have detected unusual traffic",
+];
+
+/**
+ * Decode a Google redirect wrapper (`/url?q=<real>&sa=...`) to its target.
+ * Returns the input unchanged when it is not a wrapper.
+ */
+const unwrapRedirect = (href: string): string => {
+  const wrapper = href.match(/^(?:https?:\/\/[^/]*google\.[^/]*)?\/url\?/i);
+  if (!wrapper) return href;
+  const query = href.slice(href.indexOf("?") + 1);
+  const target = new URLSearchParams(query).get("q");
+  return target ?? href;
+};
+
+const isExternalResult = (url: string): boolean => {
+  if (!/^https?:\/\//i.test(url)) return false;
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    if (host === "google.com" || host.endsWith(".google.com")) return false;
+    if (host === "googleusercontent.com" || host.endsWith(".googleusercontent.com")) return false;
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/** Normalized key for dedupe: origin + pathname, trailing slash and hash removed. */
+const dedupeKey = (url: string): string => {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname.replace(/\/$/, "")}`.toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+};
+
+/**
+ * Parse captured anchors into ranked results: unwrap redirects, keep only
+ * external http(s) links, dedupe by normalized url (first wins), rank by input
+ * order, cap to `limit`.
+ */
+export const parseGoogleSerp = (anchors: ReadonlyArray<SerpAnchor>, limit: number): ReadonlyArray<SearchResult> => {
+  const seen = new Set<string>();
+  const results: SearchResult[] = [];
+  for (const anchor of anchors) {
+    if (results.length >= limit) break;
+    const url = unwrapRedirect(anchor.href);
+    if (!isExternalResult(url)) continue;
+    const key = dedupeKey(url);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({
+      title: anchor.heading.trim(),
+      url,
+      snippet: anchor.snippet.trim(),
+      rank: results.length + 1,
+    });
+  }
+  return results;
+};
+
+/**
+ * Decide whether the SERP is usable, blocked by a CAPTCHA, or genuinely empty.
+ * `resultCount` is the number of parsed results; `pageText` is a bounded slice
+ * of the page's visible text.
+ */
+export const classifySerp = (pageText: string, resultCount: number): SerpVerdict => {
+  if (resultCount > 0) return "ok";
+  const lower = pageText.toLowerCase();
+  if (CAPTCHA_MARKERS.some((marker) => lower.includes(marker))) return "captcha";
+  return "no_results";
+};

package/src/domains/search/web-search.ts

@@ -0,0 +1,116 @@
+import { Type } from "typebox";
+import { type Result, err, ok } from "../../util/result";
+import { applyTruncation } from "../../util/truncate";
+import { defineBrowserTool, type ToolErr, type ToolOk } from "../../util/tool";
+import {
+  closeIsolatedTab,
+  evalInIsolatedTab,
+  navigateIsolatedTab,
+  openIsolatedTab,
+  waitForIsolatedLoad,
+} from "../isolated-tab";
+import { renderExpandableText } from "../render";
+import { buildSerpExtractionExpr } from "./extract";
+import { classifySerp, parseGoogleSerp, type SearchResult, type SerpExtraction } from "./google-serp";
+
+const LOAD_TIMEOUT_MS = 15_000;
+
+const WebSearchArgs = Type.Object({
+  query: Type.String({ description: "The search query." }),
+  limit: Type.Optional(
+    Type.Integer({ default: 10, minimum: 1, maximum: 30, description: "Max results to return. Default: 10." }),
+  ),
+});
+
+const buildSerpUrl = (query: string, limit: number): string =>
+  `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${limit}&hl=en`;
+
+const isSerpExtraction = (value: unknown): value is SerpExtraction => {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  return Array.isArray(v["anchors"]) && typeof v["pageText"] === "string";
+};
+
+const formatResults = (query: string, results: ReadonlyArray<SearchResult>): string => {
+  const lines = results.map((r) => `${r.rank}. ${r.title}\n   ${r.url}\n   ${r.snippet}`);
+  return `${results.length} result(s) for "${query}":\n\n${lines.join("\n\n")}`;
+};
+
+export const webSearchTool = defineBrowserTool({
+  name: "browser_web_search",
+  label: "Browser Web Search",
+  description:
+    "Search the web and return ranked results (title, url, snippet, rank). Scrapes a Google results page in the real Chrome — no API key. Returns links only; use browser_read_page to read a result's content.",
+  promptSnippet: "Search the web for a query",
+  promptGuidelines: [
+    "Returns ranked {title, url, snippet, rank} — links only, no page content. Follow up with browser_read_page.",
+    "On a CAPTCHA / bot wall the call fails with kind:'invalid_state' and details.reason:'captcha' (plus serpUrl) — surface it to the user; do not retry in a tight loop.",
+    "On zero results it fails with details.reason:'no_results' — rephrase the query and try again.",
+    "Runs in its own isolated tab and never disturbs the user's current tab.",
+  ],
+  parameters: WebSearchArgs,
+  async handler(args, { client, signal }): Promise<Result<ToolOk, ToolErr>> {
+    const limit = args.limit ?? 10;
+    const serpUrl = buildSerpUrl(args.query, limit);
+
+    const opened = await openIsolatedTab(client);
+    if (!opened.success) return err(opened.error);
+    const tab = opened.data;
+
+    try {
+      const navigated = await navigateIsolatedTab(client, tab, serpUrl);
+      if (!navigated.success) return err(navigated.error);
+
+      const loaded = await waitForIsolatedLoad(client, tab, LOAD_TIMEOUT_MS, signal);
+      if (!loaded.success) return err(loaded.error);
+
+      const extracted = await evalInIsolatedTab(client, tab, buildSerpExtractionExpr());
+      if (!extracted.success) return err(extracted.error);
+
+      const parsedJson = typeof extracted.data === "string" ? safeParse(extracted.data) : extracted.data;
+      if (!isSerpExtraction(parsedJson)) {
+        return err({ kind: "internal", message: "SERP extraction returned an unexpected shape" });
+      }
+
+      const results = parseGoogleSerp(parsedJson.anchors, limit);
+      const verdict = classifySerp(parsedJson.pageText, results.length);
+      if (verdict !== "ok") {
+        return err({
+          kind: "invalid_state",
+          message: verdict === "captcha" ? "Google served a CAPTCHA / bot wall" : "no results found",
+          details: { reason: verdict, serpUrl },
+        });
+      }
+
+      const body = formatResults(args.query, results);
+      const truncated = await applyTruncation(body, "search");
+      return ok({
+        text: truncated.text,
+        details: {
+          results,
+          engine: "google",
+          query: args.query,
+          render: {
+            summary: `${results.length} result(s) · google · "${args.query}"`,
+            body,
+            ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+          },
+          ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+        },
+      });
+    } finally {
+      await closeIsolatedTab(client, tab);
+    }
+  },
+  renderResult(result, expanded, theme) {
+    return renderExpandableText("web_search", result, expanded, theme);
+  },
+});
+
+const safeParse = (text: string): unknown => {
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return undefined;
+  }
+};

package/src/domains/setup.ts

@@ -31,8 +31,10 @@ export const setupTool = defineBrowserTool({
   // ensureAlive:false — this tool IS the setup; it must bypass the socket guard
   ensureAlive: false,
   renderCall: () => new Text("🔧 Initializing browser...", 0, 0),
-  async handler(_args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    const result = await performSetup(client);
+  async handler(_args, { client, extensionCtx }): Promise<Result<ToolOk, ToolErr>> {
+    // extensionCtx carries the UI, so the agent calling browser_setup gets the
+    // same first-run profile picker the user gets from /browser-setup.
+    const result = await performSetup(client, extensionCtx);
     if (result.success) {
       return ok({ text: result.data });
     }

package/src/index.ts

@@ -12,8 +12,10 @@
  *
  * Commands:
  *   /browser-setup          — guided setup wizard
+ *   /browser-profile        — choose which browser profile the agent uses
  *   /browser-status         — show client status and current page
  *   /browser-reload-daemon  — restart the browser client
+ *   /deep-research <q>      — research a question on the web, write a cited report
  *
  * Flags:
  *   --browser-namespace <name>   — override namespace (default: auto)
@@ -24,6 +26,9 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { type BrowserClient, createBrowserClient } from "./client";
 import { getBrowserSystemPrompt } from "./prompt";
 import { registerSetupCommand } from "./setup";
+import { registerProfileCommand } from "./profile/command";
+import { readPin } from "./profile/store";
+import { registerDeepResearchCommand } from "./deep-research";
 import { type BrowserState, defaultState, persistState, restoreState } from "./state";
 import { registerAllTools } from "./registry";
 import { cleanupTempDirs } from "./util/truncate";
@@ -55,8 +60,10 @@ export default function browserHarnessExtension(pi: ExtensionAPI): void {
         return;
       }
       const s = client.status();
+      const pin = client.profilePin();
       const lines = [
         `Browser: ${s.alive ? "🟢 Connected" : "🔴 Disconnected"}`,
+        `Profile: ${pin ? pin.label : "not selected (uses whichever window is focused) — run /browser-profile"}`,
         `Session: ${s.sessionId ?? "none"}`,
       ];
       if (s.remoteBrowserId) lines.push(`Browser ID: ${s.remoteBrowserId}`);
@@ -100,6 +107,11 @@ export default function browserHarnessExtension(pi: ExtensionAPI): void {
   pi.on("session_start", async (_event, ctx) => {
     state = restoreState(ctx, state.namespace);
 
+    // The pinned profile lives on disk, not in the session, so it survives
+    // session termination. Re-read it every session start: another pi session
+    // may have changed it since this client was created.
+    const profilePin = await readPin();
+
     // Create the client lazily on first session. The daemon transport
     // is created but NOT connected — that only happens when the user
     // runs /browser-setup or a browser tool call finds an existing socket.
@@ -107,13 +119,15 @@ export default function browserHarnessExtension(pi: ExtensionAPI): void {
     if (!client) {
       const transport = createDaemonTransport(state.namespace);
 
-      const initialOwnership: { ownedTargetIds?: ReadonlyArray<string>; harnessWindowTargetId?: string } = {};
+      const initialOwnership: { ownedTargetIds?: ReadonlyArray<string>; harnessWindowTargetId?: string; harnessWindowId?: number } = {};
       if (state.ownedTargetIds !== undefined) initialOwnership.ownedTargetIds = state.ownedTargetIds;
       if (state.harnessWindowTargetId !== undefined) initialOwnership.harnessWindowTargetId = state.harnessWindowTargetId;
+      if (state.harnessWindowId !== undefined) initialOwnership.harnessWindowId = state.harnessWindowId;
 
       client = createBrowserClient({
         namespace: state.namespace,
         transport,
+        profilePin,
         ...(Object.keys(initialOwnership).length > 0 ? { initialOwnership } : {}),
         onOwnershipChange: (snap) => {
           state = {
@@ -122,6 +136,9 @@ export default function browserHarnessExtension(pi: ExtensionAPI): void {
             ...(snap.harnessWindowTargetId !== undefined
               ? { harnessWindowTargetId: snap.harnessWindowTargetId }
               : {}),
+            ...(snap.harnessWindowId !== undefined
+              ? { harnessWindowId: snap.harnessWindowId }
+              : {}),
           };
           // Ownership changes can fire from CDP events at any time,
           // including after session replacement when pi's ctx is stale.
@@ -130,6 +147,10 @@ export default function browserHarnessExtension(pi: ExtensionAPI): void {
           try { persistState(pi, state); } catch { /* stale ctx — safe to ignore */ }
         },
       });
+    } else {
+      // Client carried over from a previous session — adopt whatever pin is on
+      // disk now, which another pi session may have changed.
+      client.setProfilePin(profilePin);
     }
 
     // Do NOT call client.start() here — browser control is on-demand.
@@ -141,27 +162,32 @@ export default function browserHarnessExtension(pi: ExtensionAPI): void {
       toolsRegistered = true;
     }
     registerSetupCommand(pi, client);
-    ctx.ui.setStatus(
-      "browser",
-      client.status().alive ? "🟢 Browser connected" : "🔴 Browser — run /browser-setup",
-    );
+    registerProfileCommand(pi, client);
+    registerDeepResearchCommand(pi);
   });
 
   pi.on("session_shutdown", async () => {
-    persistState(pi, state);
     if (client) {
       try {
         // Detach from the page target (removes the "Chrome is being controlled"
         // banner) but keep the transport alive for the next session.
         await client.detach();
+        // Close every tab this session opened so no stale harness tabs linger
+        // in the user's browser between sessions. This also clears the persisted
+        // ownership + window binding via onOwnershipChange, so the next session
+        // starts with a fresh dedicated window rather than reattaching to leftovers.
+        await client.closeOwnedTabs();
       } catch (e) {
-        console.warn("[pi-browser-harness] client.detach() failed during shutdown:", e);
+        console.warn("[pi-browser-harness] browser teardown failed during shutdown:", e);
       }
       // ponytail: keep the transport alive across sessions.
       // Do NOT call client.stop() or null out client — the daemon connection
       // persists and eliminates the per-session "Allow Remote Debugging" prompt.
       // Only Chrome restart or daemon death triggers a new prompt.
     }
+    // Persist last — closeOwnedTabs mutates `state` through onOwnershipChange,
+    // so this captures the cleared ownership set.
+    persistState(pi, state);
     await cleanupTempDirs();
   });