@tea-agent/loop-agent 0.43.0-next.13 → 0.43.0-next.15

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## [Unreleased]
 
+- Operator Chat 新增对话驱动的侧边栏浏览器自动化：模型可在工作流 / Pi 会话调用 `browser_navigate` / `browser_search` / `browser_inspect` / `browser_act`，把百度等页面打开到右侧浏览器面板，执行静态搜索、GET 表单填充提交、链接点击并返回结构化页面元素；命令通道按工作区隔离，自动化不读取或修改仓库文件，也不执行页面脚本。
+
 - 修复前端 Plan 无法提交实现步骤的问题：finalize_plan 支持按 AC 绑定实施动作，缺漏在节点内返回修正，避免空计划反复进入设计审查。
 
 - 修复前端最终审查反复猜错范围 ID：明确 checkpoint 参数和补交步骤，收尾正确识别 checkpoint 之后的审批结论。
@@ -10,6 +12,8 @@
 
 ### 改进
 
+- Console 将全局「更新程序」与当前工作区初始化分开：添加或切换工作区后只读检查并提示，设置中展示仓库路径、初始化状态、待处理文件和操作进度；首次初始化显式选择可用模型，安全更新仅作用于当前仓库，冲突保留并提示处理。
+
 - Operator Chat 内置内部 provider 瞬态异常恢复：即使目标仓库未执行 `loop-agent init`，也能识别完整或被裁剪的 `UnknownError` / `TypeValidationError` / `LLMRequestError` / 502 / 中文「网络波动、模型处理超时」响应，将其规范化后交给 Pi 原生有界重试；Console 缺省使用 loop-agent 推荐重试参数，项目显式字段优先于用户全局字段，用户配置优先于推荐默认值。共享纯分类器同时生成 OpenCode 插件谓词，overflow、认证、权限、配额、取消和业务错误继续 fail-fast。
 
 - Operator Chat 浏览器面板默认以完整权限运行（去掉 iframe 沙箱与「临时解锁」状态条），并放开本机回环地址限制——`localhost` / `127.0.0.1` / `::1` 等本地开发服务器可直接在面板内浏览；地址栏仍仅放行 http/https，`javascript:` / `data:` / `file:` 等危险协议继续拦截，拒绝嵌入站点（X-Frame-Options / frame-ancestors）的解释面板与出口保持不变。
@@ -22,6 +26,7 @@
 
 ### 修复
 
+- 对话页修复用户消息在流式回复中漏显示或重复分组、加载历史后的滚动跳动，以及删除会话后旧请求恢复条目的问题；移除工作区后隐藏非选中的空白会话，并正确恢复删除失败的列表状态。
 - 修复 Operator Chat 的跨会话输入污染与快速重复提交：切换会话时立即撤销旧会话发送权，草稿、附件和 ↑ 输入历史按会话独立保存；发送、排队、撤回、编辑、插话、文件建议和图片读取的迟到结果只回写原会话。提交改用带快照的有界 attempt，相同内容的快速双 Enter/双击只产生一次请求，失败恢复或排队响应不再覆盖后来输入；流式更新和会话切换保持同一个 composer DOM，中文 IME 更稳定。同步修复 durable 用户消息确认后时间重排导致闪烁光标跑到用户消息上方的问题。
 
 - 前端设计审查的写入门禁只统计已提交的审批终态，避免审查范围、发现记录导致合法审批被误判为缺失或歧义；要求修改时保留具体审查意见，缺失、重复及冲突终态仍阻断写入。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.43.0-next.13",
-  "gitSha": "4e92f5b2b1c43bc8971d9c9e6c21f76fa557189d",
-  "builtAt": "2026-09-11T00:55:37.486Z"
+  "version": "0.43.0-next.15",
+  "gitSha": "216714a351e09e72203f04c7143d880cc22e17ca",
+  "builtAt": "2026-09-11T05:20:15.894Z"
 }

package/dist/worker/console/chat/browser-automation.js

@@ -0,0 +1,363 @@
+/**
+ * Server-side implementation for the model-callable sidebar browser tools.
+ *
+ * Navigation is delivered to the visible BrowserPanel through a small pending
+ * command queue. Page inspection uses the same http(s) URL loaded by that
+ * panel and parses the server-visible HTML. Static GET forms are submitted as
+ * real navigations; dynamic scripts and POST forms are intentionally refused.
+ */
+import { normalizeBrowserUrl } from "./browser-policy.js";
+export class BrowserAutomationService {
+    fetchImpl;
+    pending = [];
+    sequence = 0;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async navigate(rawUrl, options) {
+        const normalized = normalizeBrowserUrl(rawUrl);
+        if (normalized.kind !== "ok") {
+            return {
+                ok: false,
+                error: normalized.kind === "invalid"
+                    ? "invalid browser url"
+                    : "browser urls must use http(s)",
+            };
+        }
+        let snapshot;
+        const snapshotSource = rewriteBaiduSearchUrlForSnapshot(normalized.url);
+        if (options?.includeSnapshot) {
+            try {
+                snapshot = await this.inspect(snapshotSource);
+            }
+            catch {
+                // Navigation itself can still succeed when the panel cannot
+                // fetch the page server-side; the iframe remains the fallback.
+            }
+        }
+        const displayUrl = snapshotSource === normalized.url ? normalized.url : snapshotSource;
+        const command = {
+            kind: "navigate",
+            id: this.nextId(),
+            url: displayUrl,
+            ...(snapshot ? { snapshot } : {}),
+            createdAt: new Date().toISOString(),
+        };
+        this.pending = [command];
+        return { ok: true, command };
+    }
+    reload() {
+        const command = {
+            kind: "reload",
+            id: this.nextId(),
+            createdAt: new Date().toISOString(),
+        };
+        this.pending = [command];
+        return { ok: true, command };
+    }
+    take() {
+        const commands = this.pending;
+        this.pending = [];
+        return commands;
+    }
+    async inspect(rawUrl) {
+        const normalized = normalizeBrowserUrl(rawUrl);
+        if (normalized.kind !== "ok")
+            throw new BrowserAutomationError("INVALID_URL", "invalid browser url");
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 12_000);
+        try {
+            const response = await this.fetchImpl(normalized.url, {
+                redirect: "follow",
+                signal: controller.signal,
+                headers: { accept: "text/html,application/xhtml+xml" },
+            });
+            const contentType = response.headers.get("content-type") ?? "";
+            if (!contentType.includes("html")) {
+                throw new BrowserAutomationError("NOT_HTML", "the browser page did not return an HTML document");
+            }
+            const html = await response.text();
+            if (html.length > 3_000_000) {
+                throw new BrowserAutomationError("PAGE_TOO_LARGE", "page exceeds 3MB");
+            }
+            return parseBrowserPage(html, response.url || normalized.url);
+        }
+        catch (error) {
+            if (error instanceof BrowserAutomationError)
+                throw error;
+            throw new BrowserAutomationError("FETCH_FAILED", "could not load the page", {
+                cause: error,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async search(rawQuery, rawUrl) {
+        const query = rawQuery.trim();
+        if (!query)
+            throw new BrowserAutomationError("EMPTY_QUERY", "search query is empty");
+        let target = rawUrl?.trim() ? rawUrl.trim() : "https://m.baidu.com/s?wd=";
+        const normalized = normalizeBrowserUrl(target);
+        if (normalized.kind !== "ok") {
+            throw new BrowserAutomationError("INVALID_URL", "search engine url must use http(s)");
+        }
+        const url = new URL(normalized.url);
+        url.searchParams.set(url.searchParams.has("q") ? "q" : "wd", query);
+        const result = await this.navigate(url.href, { includeSnapshot: true });
+        if (!result.ok)
+            throw new BrowserAutomationError("INVALID_URL", result.error);
+        return result.command.kind === "navigate" && result.command.snapshot
+            ? result.command.snapshot
+            : await this.inspect(url.href);
+    }
+    async act(rawUrl, request) {
+        const snapshot = await this.inspect(rawUrl);
+        const element = selectBrowserElement(snapshot, request);
+        if (!element) {
+            throw new BrowserAutomationError("ELEMENT_NOT_FOUND", "selector did not match a clickable element or form field");
+        }
+        if (request.type === "fill") {
+            if (element.tag !== "input" && element.tag !== "textarea") {
+                throw new BrowserAutomationError("NOT_FILLABLE", "matched element is not fillable");
+            }
+            const submitted = this.submitForm(snapshot, element, request.value);
+            const submittedSnapshot = await this.inspect(submitted.url);
+            const navigation = await this.navigate(submitted.url, { includeSnapshot: true });
+            if (!navigation.ok)
+                throw new BrowserAutomationError("INVALID_URL", navigation.error);
+            return {
+                ...submittedSnapshot,
+                action: { type: "fill", selector: request.selector, value: request.value, url: submitted.url },
+            };
+        }
+        const formSubmit = element.clickable && element.formIndex !== undefined && !element.href
+            ? this.submitForm(snapshot, element)
+            : undefined;
+        const targetUrl = formSubmit?.url ?? element.href;
+        if (targetUrl === undefined) {
+            throw new BrowserAutomationError("NOT_CLICKABLE", "matched element has no safe click target");
+        }
+        const navigation = await this.navigate(targetUrl, { includeSnapshot: true });
+        if (!navigation.ok)
+            throw new BrowserAutomationError("INVALID_URL", navigation.error);
+        return {
+            ...snapshot,
+            action: {
+                type: "click",
+                selector: request.selector,
+                url: targetUrl,
+            },
+        };
+    }
+    submitForm(snapshot, target, valueOverride) {
+        if (target.formIndex === undefined) {
+            throw new BrowserAutomationError("FORM_NOT_FOUND", "matched field is not inside a form");
+        }
+        if ((target.formMethod ?? "get") !== "get") {
+            throw new BrowserAutomationError("FORM_METHOD_NOT_SUPPORTED", "only GET forms can be automated without browser scripts");
+        }
+        const url = new URL(target.formAction ?? snapshot.url);
+        for (const element of snapshot.elements) {
+            if (element.formIndex !== target.formIndex || !element.name)
+                continue;
+            if (element.tag === "button")
+                continue;
+            if (element.tag === "input" && ["submit", "button", "reset", "image"].includes(element.type ?? "")) {
+                continue;
+            }
+            const value = element.selector === target.selector && valueOverride !== undefined
+                ? valueOverride
+                : element.value ?? "";
+            url.searchParams.set(element.name, value);
+        }
+        return { url: url.href };
+    }
+    nextId() {
+        this.sequence += 1;
+        return `browser-${Date.now().toString(36)}-${this.sequence}`;
+    }
+}
+export class BrowserAutomationError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "BrowserAutomationError";
+    }
+}
+export function rewriteBaiduSearchUrlForSnapshot(rawUrl) {
+    try {
+        const url = new URL(rawUrl);
+        if (url.protocol !== "https:" || url.hostname !== "www.baidu.com")
+            return rawUrl;
+        if (url.pathname.replace(/\/+$/, "") !== "/s")
+            return rawUrl;
+        const query = url.searchParams.get("wd") ?? url.searchParams.get("word");
+        if (query === null)
+            return rawUrl;
+        const mobile = new URL("https://m.baidu.com/s");
+        mobile.searchParams.set("wd", query);
+        return mobile.href;
+    }
+    catch {
+        return rawUrl;
+    }
+}
+const SKIP_TAGS = new Set(["script", "style", "template", "noscript"]);
+const INTERACTIVE_TAGS = new Set(["a", "button", "input", "select", "textarea"]);
+export function parseBrowserPage(html, baseUrl) {
+    const state = { snapshot: { url: baseUrl, title: "", elements: [] }, nextFormIndex: 0 };
+    const tokenizer = /<!--[\s\S]*?-->|<\/?([a-zA-Z][a-zA-Z0-9:-]*)([^>]*)>/g;
+    const openTags = [];
+    let cursor = 0;
+    let match;
+    while ((match = tokenizer.exec(html)) !== null) {
+        const text = decodeEntities(html.slice(cursor, match.index)).replace(/\s+/g, " ").trim();
+        const parent = openTags[openTags.length - 1];
+        if (parent && !SKIP_TAGS.has(parent.tag))
+            appendText(parent, text);
+        cursor = match.index + match[0].length;
+        if (match[0].startsWith("<!--"))
+            continue;
+        const tag = match[1]?.toLowerCase() ?? "";
+        const attrs = parseAttributes(match[2] ?? "");
+        if (match[0].startsWith("</")) {
+            const index = findOpenTag(openTags, tag);
+            if (index >= 0) {
+                const closed = openTags[index];
+                openTags.length = index;
+                closeElement(state, closed, baseUrl);
+            }
+            continue;
+        }
+        const parentForForm = openTags[openTags.length - 1];
+        let form = parentForForm?.form;
+        if (tag === "form" && !form) {
+            form = {
+                index: state.nextFormIndex,
+                action: attrs.action,
+                method: attrs.method?.toLowerCase(),
+            };
+            state.nextFormIndex += 1;
+        }
+        const element = { tag, attrs, text: "", form };
+        if (/\/>$/.test(match[0]) || isVoidTag(tag)) {
+            closeElement(state, element, baseUrl);
+        }
+        else {
+            openTags.push(element);
+        }
+    }
+    if (state.snapshot.elements.length > 300)
+        state.snapshot.elements.length = 300;
+    return state.snapshot;
+}
+function parseAttributes(raw) {
+    const attrs = {};
+    const pattern = /([:@a-zA-Z_#][^\s"'<>`=]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g;
+    let match;
+    while ((match = pattern.exec(raw)) !== null) {
+        attrs[match[1]?.toLowerCase() ?? ""] = decodeEntities(match[2] ?? match[3] ?? match[4] ?? "");
+    }
+    return attrs;
+}
+function isVoidTag(tag) {
+    return tag === "input" || tag === "img" || tag === "br" || tag === "hr" || tag === "meta" || tag === "link";
+}
+function findOpenTag(stack, tag) {
+    for (let index = stack.length - 1; index >= 0; index -= 1) {
+        if (stack[index]?.tag === tag)
+            return index;
+    }
+    return -1;
+}
+function appendText(target, text) {
+    target.text = target.text ? `${target.text} ${text}` : text;
+}
+function closeElement(state, element, baseUrl) {
+    const { tag, attrs, text } = element;
+    if (tag === "title") {
+        state.snapshot.title = text.slice(0, 300);
+        return;
+    }
+    if (!INTERACTIVE_TAGS.has(tag))
+        return;
+    let href;
+    if (tag === "a" && attrs.href && !/^(javascript|mailto|tel):/i.test(attrs.href.trim())) {
+        try {
+            href = new URL(attrs.href, baseUrl).href;
+        }
+        catch {
+            href = undefined;
+        }
+    }
+    const id = attrs.id;
+    const name = attrs.name;
+    const selector = buildSelector(tag, id, name, attrs.class, state.snapshot.elements.length);
+    const rawText = text || attrs.value || attrs.placeholder || attrs["aria-label"] || attrs.title || "";
+    state.snapshot.elements.push({
+        tag,
+        ...(id ? { id } : {}),
+        text: rawText.replace(/\s+/g, " ").trim().slice(0, 240),
+        ...(href ? { href } : {}),
+        ...(name ? { name } : {}),
+        ...(attrs.type ? { type: attrs.type } : {}),
+        ...(attrs.value ? { value: attrs.value } : {}),
+        ...(attrs.placeholder ? { placeholder: attrs.placeholder } : {}),
+        ...(element.form ? { formIndex: element.form.index } : {}),
+        ...(element.form ? {
+            formAction: element.form.action === undefined
+                ? baseUrl
+                : new URL(element.form.action, baseUrl).href,
+            formMethod: element.form.method ?? "get",
+        } : {}),
+        selector,
+        clickable: tag === "a" || tag === "button" || (tag === "input" && ["submit", "button", "radio", "checkbox"].includes(attrs.type ?? "")),
+    });
+}
+function buildSelector(tag, id, name, className, index) {
+    if (id)
+        return `#${escapeSelectorValue(id)}`;
+    if (name)
+        return `${tag}[name="${escapeSelectorValue(name)}"]`;
+    if (className?.trim()) {
+        const firstClass = className.trim().split(/\s+/)[0];
+        if (firstClass)
+            return `${tag}.${escapeSelectorValue(firstClass)}`;
+    }
+    return `${tag}:nth-of-type(${index + 1})`;
+}
+function escapeSelectorValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+export function selectBrowserElement(snapshot, request) {
+    const selector = request.selector.trim();
+    if (!selector)
+        return undefined;
+    return snapshot.elements.find((element) => element.selector === selector)
+        ?? snapshot.elements.find((element) => element.id === selector.slice(1))
+        ?? snapshot.elements.find((element) => element.name === selector)
+        ?? snapshot.elements.find((element) => element.text.toLowerCase().includes(selector.toLowerCase()) && selector.length >= 2);
+}
+const ENTITY_MAP = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: "\"",
+    apos: "'",
+    nbsp: " ",
+};
+function decodeEntities(value) {
+    return value.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (whole, entity) => {
+        if (entity.startsWith("#x") || entity.startsWith("#X")) {
+            const code = Number.parseInt(entity.slice(2), 16);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
+        }
+        if (entity.startsWith("#")) {
+            const code = Number.parseInt(entity.slice(1), 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
+        }
+        return ENTITY_MAP[entity.toLowerCase()] ?? whole;
+    });
+}

package/dist/worker/console/chat/browser-routes.js

@@ -6,7 +6,7 @@
  * caller), restricted to http(s) URLs, with a hard timeout. Local addresses
  * are allowed — the panel routinely browses local dev servers.
  */
-import { embeddabilityOf, extractFrameAncestors, } from "./browser-policy.js";
+import { embeddabilityOf, extractFrameAncestors, normalizeBrowserUrl, } from "./browser-policy.js";
 function workspaceIdOf(req) {
     try {
         return new URL(req.url ?? "/", "http://localhost").searchParams.get("workspaceId") ?? undefined;
@@ -52,24 +52,20 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
             }
             const url = new URL(req.url ?? "/", "http://localhost");
             const raw = url.searchParams.get("url") ?? "";
-            let parsed;
-            try {
-                parsed = new URL(raw);
-            }
-            catch {
-                sendJson(res, 400, {
-                    ok: false,
-                    error: { code: "INVALID_URL", message: "invalid url" },
-                });
-                return true;
-            }
-            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            const normalized = normalizeBrowserUrl(raw);
+            if (normalized.kind !== "ok") {
                 sendJson(res, 400, {
                     ok: false,
-                    error: { code: "BAD_SCHEME", message: "only http/https urls can be probed" },
+                    error: {
+                        code: normalized.kind === "blocked" ? "BAD_SCHEME" : "INVALID_URL",
+                        message: normalized.kind === "blocked"
+                            ? "only http/https urls can be probed"
+                            : "invalid url",
+                    },
                 });
                 return true;
             }
+            const parsed = new URL(normalized.url);
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), 8000);
             try {
@@ -116,6 +112,32 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 clearTimeout(timer);
             }
         }
+        if (method === "GET" && sub === "commands" && parts.length === 1) {
+            const ws = workspaceIdOf(req);
+            if (!ws) {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
+                });
+                return true;
+            }
+            if (deps.requireWorkspace) {
+                const scope = deps.requireWorkspace(req);
+                if (!scope.ok) {
+                    sendJson(res, 403, {
+                        ok: false,
+                        error: { code: "WORKSPACE_DENIED", message: "workspace scope mismatch" },
+                    });
+                    return true;
+                }
+            }
+            if (!deps.automation) {
+                sendJson(res, 200, { ok: true, data: { commands: [] } });
+                return true;
+            }
+            sendJson(res, 200, { ok: true, data: { commands: deps.automation.take() } });
+            return true;
+        }
         sendJson(res, 404, {
             ok: false,
             error: { code: "NOT_FOUND", message: `unknown browser route: ${method} ${pathname}` },

package/dist/worker/console/chat/pi-runtime/custom-tools/browser-tools.js

@@ -0,0 +1,89 @@
+/**
+ * Session-independent browser tools shared by workflow and Pi chat modes.
+ * Navigation is visible in the Console sidebar; inspection is server-side and
+ * bounded to avoid exposing raw credentials or arbitrary page scripts.
+ */
+const BROWSER_TOOLS_DESCRIPTION = "Operate the Console sidebar browser. `browser_navigate` shows a URL in the panel; `browser_search` opens a search URL and returns elements; `browser_inspect` returns title/links/form controls; `browser_act` fills/submits a static GET form or clicks a static link. For natural-language search requests, prefer `browser_search` over navigating to a homepage and simulating its form. It never edits the workspace and cannot execute browser scripts. Dynamic-page and POST-form operations are out of scope.";
+export async function buildBrowserTools(options) {
+    const [{ Type }, { defineTool }] = await Promise.all([
+        import("typebox"),
+        import("@earendil-works/pi-coding-agent"),
+    ]);
+    const automation = options.automation;
+    const urlParameter = Type.String({
+        description: "Absolute http(s) URL. Prefer URLs/element selectors returned by prior browser tools.",
+    });
+    async function execute(operation) {
+        try {
+            const result = await operation();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                details: result,
+            };
+        }
+        catch (error) {
+            const payload = {
+                error: error instanceof Error ? error.message : String(error),
+                code: error instanceof Error && "code" in error
+                    ? String(error.code)
+                    : "BROWSER_OPERATION_FAILED",
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(payload) }],
+                details: payload,
+            };
+        }
+    }
+    return [
+        defineTool({
+            name: "browser_navigate",
+            label: "Sidebar browser navigate",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({ url: urlParameter }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.navigate(params.url, { includeSnapshot: true }));
+            },
+        }),
+        defineTool({
+            name: "browser_search",
+            label: "Sidebar browser search",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({
+                query: Type.String({ description: "Search query." }),
+                engineUrl: Type.Optional(urlParameter),
+            }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.search(params.query, params.engineUrl));
+            },
+        }),
+        defineTool({
+            name: "browser_inspect",
+            label: "Sidebar browser inspect",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({ url: urlParameter }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.inspect(params.url));
+            },
+        }),
+        defineTool({
+            name: "browser_act",
+            label: "Sidebar browser act",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({
+                url: urlParameter,
+                type: Type.Union([Type.Literal("click"), Type.Literal("fill")]),
+                selector: Type.String({ description: "Selector returned by browser_inspect." }),
+                value: Type.Optional(Type.String()),
+            }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.act(params.url, params.type === "click"
+                    ? { type: "click", selector: params.selector }
+                    : { type: "fill", selector: params.selector, value: params.value ?? "" }));
+            },
+        }),
+    ];
+}

package/dist/worker/console/chat/pi-runtime.js

@@ -43,12 +43,14 @@ import { incrementCounter as incrementPressureCounter } from "../../../shared/pi
 import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.js";
 import { filterActiveInterviewTools } from "../interview/tools.js";
 import { redactRuntimeText } from "./runtime-context.js";
+import { BrowserAutomationService } from "./browser-automation.js";
 import { buildTodoContinuationContext, } from "./todos.js";
 import { buildPersistentTerminalTools } from "./terminal-tools.js";
 import { buildScmTools } from "./scm-tools.js";
 import { buildGoalContinuationContext, } from "./goals.js";
 import { injectWizardLocalHeaders, } from "./sdd-data-alignment.js";
 import { buildCustomOperatorTools } from "./pi-runtime/custom-tools/operator-tools.js";
+import { buildBrowserTools } from "./pi-runtime/custom-tools/browser-tools.js";
 import { buildAskUserQuestionTool } from "./pi-runtime/custom-tools/ask-user-question.js";
 import { buildTodoWriteTool } from "./pi-runtime/custom-tools/todo-write.js";
 import { buildGoalTools } from "./pi-runtime/custom-tools/goal-tools.js";
@@ -78,7 +80,7 @@ import { createDefaultPiSdkBindings, safeGetAgentDir, } from "./pi-runtime/sdk-b
  */
 export const OPERATOR_CHAT_SYSTEM_PROMPT_BASE = [
     "You are General Operator Chat.",
-    "Use operator tools first (dagReport, dagRerunPlan, dagRerun). Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for probes.",
+    "Use operator tools first (dagReport, dagRerunPlan, dagRerun). Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for probes. Browser_* drives the visible Browser panel only (static http(s), no workspace edits/scripts).",
     "No harness and asked to init: `loop-agent init instructions --repo-root .`, then `loop-agent init --repo-root . --profile full --merge`; verify with doctor, inspect and docs audit. Updates: `loop-agent init upgrade --repo-root . --json` until stable; `loop-agent init check-update` is read-only.",
     "Long DAGs: prepareDagExecution → runDag → operationId. Never foreground-Bash task advance, tail/head pipes or nohup/Start-Process/start; do not end on accepted/queued/running or an operationId — NOT completion. Supervise operationGet/status/dagReport/dagDoctor/operationWait at 60s → 90s → 120s → 180s; reset to 60s on state change; 30-60s re-checks when stall suspected. operationWait MUST use afterSeq=previous nextSeq (recommendedNextCall). Heartbeats: not meaningful progress. Run id ≠ task id.",
     "Failure: terminal runSummary first. With progress wait; else dagRerunPlan(fromNode=primaryFailure.nodeId); eligible → dagRerun: reruns the failed subgraph, keeps prior successes. Ineligible: Worker → workerTaskRetry; standalone → standaloneTaskRerun after contract adopt (regenerates the whole task, not node continue). Do not call dagResume; do not re-advance a run-failed task. Pre-run identical state twice: stop and report; never loop identical bash/read/grep. Approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
@@ -415,10 +417,12 @@ export class ConsolePiRuntime {
     exploreCustomToolsPromise;
     exploreOrchestrator;
     bindings;
+    browserAutomation;
     constructor(options) {
         this.options = options;
         this.loader = createOperatorChatResourceLoader();
         this.bindings = options.bindings ?? createDefaultPiSdkBindings();
+        this.browserAutomation = options.browserAutomation ?? new BrowserAutomationService();
         this.exploreOrchestrator = new ExploreOrchestrator({
             cwd: this.options.cwd,
             bindings: this.bindings,
@@ -972,6 +976,9 @@ export class ConsolePiRuntime {
                 : Promise.resolve([]),
             this.loadExploreCustomTools(),
         ]);
+        const browserTools = await buildBrowserTools({
+            automation: this.browserAutomation,
+        });
         const questionTool = this.options.questionRegistry
             ? await buildAskUserQuestionTool({
                 sessionId,
@@ -1030,6 +1037,7 @@ export class ConsolePiRuntime {
             ...goalTools,
             ...terminalTools,
             ...scmTools,
+            ...browserTools,
             ...(agentTool ? [agentTool] : []),
         ];
     }

package/dist/worker/console/chat/routes.js

@@ -4280,7 +4280,12 @@ async function dispatchChatRequest(req, res, deps, pathname, workspaceScope) {
         }
     }
     // Browser probe API (read-only; explains iframe refusals to the panel).
-    if (await handleBrowserRequest(req, res, {}, pathname)) {
+    if (await handleBrowserRequest(req, res, {
+        automation: deps.browserAutomation,
+        requireWorkspace: () => workspaceScope
+            ? { ok: true, workspaceId: workspaceScope }
+            : { ok: false },
+    }, pathname)) {
         return true;
     }
     if (!pathname.startsWith("/api/operator/v1/chat/") &&

package/dist/worker/console/chat/session-mode.js

@@ -74,6 +74,7 @@ export const PI_CHAT_SYSTEM_PROMPT_BASE = [
     "Use read/write/edit/bash/grep/find/ls to inspect and change the workspace. apply_patch, full-tools, shell and coding-chat are denied.",
     "Agent (Explore) is a built-in read-only subagent for path-uncertain codebase search. Do not use it for a known single-file read. Prefer safe-read/safe-grep for secret-safe probes.",
     "ask_user_question pauses for a real user answer. todo_write tracks the current work and is restored after compression; it is not a workflow auto-continue signal. The persistent terminal tool is available.",
+    "Sidebar browser tools (browser_navigate/search/inspect/act) drive the visible Browser panel for user-requested web research and static automation; they never edit workspace files or execute page scripts.",
     "Goal tools (get_goal / create_goal / update_goal) track the session's durable cross-turn objective. Create a Goal only when the user explicitly asks to start one; iterate in bounded rounds until complete or blocked.",
     "This session keeps Console compression (L0/L1/L2, sift, strict checkpoint) and existing Aimax / SDD access. Do not create tasks, run DAGs, or start requirement interviews from this session.",
     "Obey repository AGENTS.md, skills and extensions when they apply. Choosing Pi mode is not extra write authorization and does not bypass Console access control or output scrubbing.",

package/dist/worker/console/chat/tools.js

@@ -25,6 +25,10 @@ export const OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS = Object.freeze([
     OPERATOR_CHAT_AGENT_TOOL_NAME,
     "terminal",
     "scm",
+    "browser_navigate",
+    "browser_search",
+    "browser_inspect",
+    "browser_act",
 ]);
 /**
  * Actions the model MAY invoke. Derived from the registry but filtered by the