@tea-agent/loop-agent 0.43.0-next.14 → 0.43.0-next.16

package/CHANGELOG.md

@@ -2,11 +2,21 @@
 
 ## [Unreleased]
 
+- 修复前端实现因测试名称没有 VT 编号而反复失败：按测试命令与文件关联执行结果，保留已有测试名称及测试失败阻断。
+
+- 整理设置弹窗布局：当前工作区优先、待处理文件紧凑分组、详情按需展开，全局程序信息收拢；窄屏导航改为横向排列。
+
+- 工作区配置按实际能力提供更新按钮，逐文件说明待处理原因与下一步，并支持复制智能体处理说明；只剩合并或确认项时不再显示无效更新按钮。
+
+- 前端实现恢复已有测试维护与执行：优先任务声明，否则复用项目测试入口；没有测试时不强制补框架，避免只构建通过却遗漏旧单测回归。
+
+- Operator Chat 新增对话驱动的侧边栏浏览器自动化：模型可在工作流 / Pi 会话调用 `browser_navigate` / `browser_search` / `browser_inspect` / `browser_act`，把百度等页面打开到右侧浏览器面板，执行静态搜索、GET 表单填充提交、链接点击并返回结构化页面元素；命令通道按工作区隔离，自动化不读取或修改仓库文件，也不执行页面脚本。
+
 - 修复前端 Plan 无法提交实现步骤的问题：finalize_plan 支持按 AC 绑定实施动作，缺漏在节点内返回修正，避免空计划反复进入设计审查。
 
 - 修复前端最终审查反复猜错范围 ID：明确 checkpoint 参数和补交步骤，收尾正确识别 checkpoint 之后的审批结论。
 
-- 前端实现流程简化为需求实现覆盖审查和 `npm run build`，不再强制单测或测试方案；行为测试可后补，构建结果不冒充行为验证。
+- 前端实现流程简化为需求实现覆盖审查与项目验证命令，不强制独立测试方案；已有测试仍需维护并执行，无测试项目不强制补框架，构建结果不冒充行为验证。
 
 ### 改进
 

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.43.0-next.14",
-  "gitSha": "31d48ba3bc6eecc584ff9fe66f78c095dcf0ca2e",
-  "builtAt": "2026-09-11T02:21:26.141Z"
+  "version": "0.43.0-next.16",
+  "gitSha": "237591777d28ec25d8ecb561db2bd0e64380e05c",
+  "builtAt": "2026-09-11T07:27:48.993Z"
 }

package/dist/executors/dag-pi-executor.js

@@ -2070,7 +2070,7 @@ export async function createFrontendPlanLedgerTools(input) {
     const recordPlanVerificationTargetTool = defineTool({
         name: "record_plan_verification_target",
         label: "record_plan_verification_target",
-        description: "Commit one plan verification target entry (origin=plan plan-verification-target fact). Reference a frozen verification command by commandId (see the frozen command directory in your prompt: static commands are project-wide checks traced by file and command only; behavior commands need a test file whose describe/it/test title contains the target id). For behavior targets, call once per distinct behavior, not mechanically once per requirement: one target may cover multiple related requirementIds. For a correction, re-submit the same id with replace=true; the ledger compiles the latest replacement. A behavior target id is the stable trace token that implementation must place in a real describe/it/test title. Entry carries id, commandId, file, requirementIds, and uiStates; optional scope (unit | component | integration) is display-only. Free-form symbol text is not accepted. IMPORTANT: batch up to 4 record_* calls per assistant message; never batch more than 4 — a larger single message risks output truncation under a small output window. Example: {\"entry\": {\"id\": \"VT-DASHBOARD-SHELL\", \"commandId\": \"<frozen behavior command id>\", \"file\": \"<test file>\", \"requirementIds\": [\"AC-001\", \"AC-002\"], \"uiStates\": []}}" +
+        description: "Commit one plan verification target entry (origin=plan plan-verification-target fact). Reference a frozen verification command by commandId (see the frozen command directory in your prompt: static commands are project-wide checks traced by file and command only; behavior commands bind an existing affected test file; preserve its test names). For behavior targets, call once per distinct behavior, not mechanically once per requirement: one target may cover multiple related requirementIds. For a correction, re-submit the same id with replace=true; the ledger compiles the latest replacement. A target id identifies a contract entry only; never require it in test names. Results bind by frozen command and test file. Entry carries id, commandId, file, requirementIds, and uiStates; optional scope (unit | component | integration) is display-only. Free-form symbol text is not accepted. IMPORTANT: batch up to 4 record_* calls per assistant message; never batch more than 4 — a larger single message risks output truncation under a small output window. Example: {\"entry\": {\"id\": \"VT-DASHBOARD-SHELL\", \"commandId\": \"<frozen behavior command id>\", \"file\": \"<test file>\", \"requirementIds\": [\"AC-001\", \"AC-002\"], \"uiStates\": []}}" +
             (input.canonicalVerificationTargetIds &&
                 input.canonicalVerificationTargetIds.length > 0
                 ? ` Frozen canonical behavior target ids (use exactly for behavior targets): ${input.canonicalVerificationTargetIds.join(", ")}.`
@@ -3763,7 +3763,7 @@ const FRONTEND_PLAN_SEGMENTS = [
         ]),
         instruction: [
             "PLAN PHASE — requirement coverage only.",
-            "Your ONLY job: for every frozen requirement, emit record_plan_requirement (requirement → implementation files) and record_plan_verification_target facts (verification target bound to requirement ids and files). Group related requirements under one non-static behavior target when one observable test behavior proves them together; do not mechanically create one target per requirement. A non-static target id is the stable machine trace token; never submit prose as a symbol. Do NOT record components, UI states, mock, dependency, or routes — a follow-up session owns those.",
+            "Your ONLY job: for every frozen requirement, emit record_plan_requirement (requirement → implementation files) and record_plan_verification_target facts (verification target bound to requirement ids and files). Group related requirements under one non-static behavior target when one observable test behavior proves them together; do not mechanically create one target per requirement. Target ids identify contract entries, not test-title markers. Reuse affected existing test files and their names; do not add tests or rename titles just to carry generated ids. Never submit prose as a symbol. Do NOT record components, UI states, mock, dependency, or routes — a follow-up session owns those.",
             "A coverage session is complete only when EVERY requirement assigned to this session (the full inventory, or the exact COVERAGE BATCH / shard list when present) has committed coverage facts: a record_plan_requirement entry plus verification targets, or a committed evidence gap. Keep committing in batches of up to 4 record_* calls per assistant message until then; do not write a concluding summary while any assigned requirement is still uncommitted — an early stop strands the remainder into a MISSING-FACT repair session and doubles the sessions needed.",
             "If a requirement genuinely cannot have a verification target, record a non-empty record_plan_evidence_gap. Do not call finalize_plan; it is not available in this phase.",
         ].join(" "),

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/") &&