Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
fix(browser): use unmodified BrowserSkill upstream and remove downstream patches (#3563)
lyingbuga89a5a2c43de
diff --git a/docker/Dockerfile.app b/docker/Dockerfile.appindex f767ef568..79f1456bd 100644--- a/docker/Dockerfile.app+++ b/docker/Dockerfile.app@@ -8,7 +8,6 @@ ENV RUSTUP_HOME=/usr/local/rustup CARGO_HOME=/usr/local/cargoENV PATH=/usr/local/cargo/bin:$PATHRUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stableCOPY scripts/build_browserskill.sh scripts/browserskill-release.json ./scripts/-COPY patches/browserskill ./patches/browserskillARG TARGETOSARG TARGETARCHRUN bash scripts/build_browserskill.sh /opt/weknora/browserskill "${TARGETOS}/${TARGETARCH}"diff --git a/frontend/src/i18n/locales/en-US.ts b/frontend/src/i18n/locales/en-US.tsindex 268f95a0e..9c05788b4 100755--- a/frontend/src/i18n/locales/en-US.ts+++ b/frontend/src/i18n/locales/en-US.ts@@ -78,13 +78,13 @@ export default {"pause": "Pause browser","start": "Start task","stop": "End browser task",- "pairHint": "Paste the pairing link into Remote connection in the extension and confirm the server.",+ "pairHint": "Open Connection settings → Remote connection in the extension, paste the pairing link, and confirm the server. The link is valid for 5 minutes and can be used once.","copyPairing": "Copy pairing link","copied": "Copied",- "windowHint": "Tasks run in a labeled Chrome tab group. Existing tabs require your permission.",+ "windowHint": "Tasks run in a separate Chrome Agent Window. Borrowing existing tabs requires your permission.","preview": "Local browser task preview","waiting": "Waiting for a task page",- "startHint": "A browser request creates labeled task tabs in the background.",+ "startHint": "A browser request creates a separate Agent Window.","revoke": "Revoke device access","revokeConfirm": "You will need to pair again before using the local browser.","failed": "Operation failed. Please retry.",@@ -96,8 +96,10 @@ export default {"reconnectHint": "Authorization is saved. Keep Chrome and BrowserSkill open to reconnect automatically.","replaceDevice": "Change browser","installExtension": "Install BrowserSkill",- "installHint": "Download the extension built for this server and install it in Chrome.",- "downloadExtension": "Download extension",+ "installHint": "Use the matching package for this server; the official store version may receive updates later.",+ "downloadExtension": "Download matching package",+ "officialExtension": "Official extension (Chrome Web Store)",+ "installGuide": "How do I install the downloaded package?","pairBrowser": "Connect this browser","packageUnavailable": "Ask your administrator for the matching extension package; a download is not configured yet.","manualCopy": "Select and copy the link below. It expires in 5 minutes and can be used once.",@@ -105,11 +107,11 @@ export default {"copyAgain": "Copy again","usageTitle": "How to use","usageStep1Title": "Install the extension",- "usageStep1Text": "Unzip the package, enable Developer mode on the Chrome extensions page, and choose Load unpacked.",+ "usageStep1Text": "Unzip the downloaded ZIP, enter chrome://extensions in the Chrome address bar, enable Developer mode, choose Load unpacked, and select the extracted extension folder.","usageStep2Title": "Pair this browser",- "usageStep2Text": "Copy the pairing link and paste it into Remote connection in the extension. Pair once for all conversations in this space.",+ "usageStep2Text": "Copy the pairing link into Connection settings → Remote connection in the extension and confirm the server. Pair once for all conversations in this space.","usageStep3Title": "Describe the task in chat",- "usageStep3Text": "Turn on the local browser in the input bar and describe the web task. It runs in a labeled tab group.",+ "usageStep3Text": "Turn on Local browser in the conversation input bar before sending a web task. Pairing does not enable this option automatically. Tasks run in a separate Agent Window.","usageStep4Title": "Preview, locate, and resume","usageStep4Text": "A small preview appears in the conversation. Click it to find the task tab. Interrupted tasks stay paused after reconnect — resume them from the preview. Existing tabs require your permission.","running": "Running",diff --git a/frontend/src/i18n/locales/ja-JP.ts b/frontend/src/i18n/locales/ja-JP.tsindex 9d33e77da..ec6c13ed9 100644--- a/frontend/src/i18n/locales/ja-JP.ts+++ b/frontend/src/i18n/locales/ja-JP.ts@@ -78,13 +78,13 @@ export default {"pause": "操作を一時停止","start": "タスクを開始","stop": "ブラウザータスクを終了",- "pairHint": "拡張機能の「リモート接続」にリンクを貼り付け、サーバーを確認します。",+ "pairHint": "拡張機能の「接続設定 → リモート接続」にリンクを貼り付け、サーバーを確認します。リンクは 5 分間有効で、1 回限り使用できます。","copyPairing": "ペアリングリンクをコピー","copied": "コピーしました",- "windowHint": "タスクはラベル付きのタブグループで実行されます。既存タブには許可が必要です。",+ "windowHint": "タスクは独立した Chrome タスクウィンドウで実行されます。既存のタブを借りるには許可が必要です。","preview": "ローカルブラウザーのプレビュー","waiting": "タスクのページを待っています",- "startHint": "ブラウザーのタスクを送ると、バックグラウンドにタスクタブを作成します。",+ "startHint": "ブラウザーへのリクエストで独立したタスクウィンドウが作成されます。","revoke": "デバイスの認証を取り消す","revokeConfirm": "取り消すと、ローカルブラウザーを使うには再度ペアリングが必要です。","failed": "操作に失敗しました。再試行してください。",@@ -96,8 +96,10 @@ export default {"reconnectHint": "認証は保存されています。Chrome と拡張機能を開くと自動的に再接続します。","replaceDevice": "ブラウザーを変更","installExtension": "BrowserSkill をインストール",- "installHint": "このサーバー用の拡張機能を Chrome にインストールします。",- "downloadExtension": "拡張機能をダウンロード",+ "installHint": "このサーバーに対応するパッケージを推奨します。公式ストアへの更新反映は遅れる場合があります。",+ "downloadExtension": "対応パッケージをダウンロード",+ "officialExtension": "公式拡張機能(Chrome ウェブストア)",+ "installGuide": "ダウンロードしたパッケージのインストール方法","pairBrowser": "ブラウザーを接続","packageUnavailable": "対応する拡張機能パッケージを管理者から入手してください。","manualCopy": "下のリンクをコピーしてください。有効期限は 5 分、使用は 1 回限りです。",@@ -105,11 +107,11 @@ export default {"copyAgain": "再コピー","usageTitle": "使い方","usageStep1Title": "拡張機能をインストール",- "usageStep1Text": "拡張を解凍し、Chrome の拡張機能ページでデベロッパーモードを有効にして読み込みます。",+ "usageStep1Text": "ZIP を解凍し、Chrome のアドレスバーに chrome://extensions と入力します。「デベロッパーモード」を有効にし、「パッケージ化されていない拡張機能を読み込む」から解凍した拡張機能フォルダーを選択します。","usageStep2Title": "ブラウザーをペアリング",- "usageStep2Text": "ペアリングリンクをコピーし、拡張機能の「リモート接続」に貼り付けてサーバーを確認します。同じスペースの会話で共有されます。",+ "usageStep2Text": "ペアリングリンクを拡張機能の「接続設定 → リモート接続」に貼り付け、サーバーを確認します。同じスペースのすべての会話で共有されます。","usageStep3Title": "会話でタスクを伝える",- "usageStep3Text": "入力欄でローカルブラウザーをオンにし、行うウェブタスクを伝えてください。ラベル付きのタブグループで実行されます。",+ "usageStep3Text": "ウェブタスクを送る前に、会話の入力欄で「ローカルブラウザー」をオンにしてください。ペアリングだけでは自動でオンになりません。タスクは独立したタスクウィンドウで実行されます。","usageStep4Title": "プレビューで確認・再開","usageStep4Text": "会話に小さなプレビューが表示されます。クリックするとタスクタブに移動できます。中断したタスクは再接続後も一時停止するので、プレビューから再開してください。既存タブには許可が必要です。","running": "実行中",diff --git a/frontend/src/i18n/locales/ko-KR.ts b/frontend/src/i18n/locales/ko-KR.tsindex 984576bf8..abaab80bd 100755--- a/frontend/src/i18n/locales/ko-KR.ts+++ b/frontend/src/i18n/locales/ko-KR.ts@@ -78,13 +78,13 @@ export default {"pause": "조작 일시 중지","start": "작업 시작","stop": "브라우저 작업 종료",- "pairHint": "확장 프로그램의 원격 연결에 링크를 붙여넣고 서버를 확인하세요.",+ "pairHint": "확장 프로그램의 연결 설정 → 원격 연결에 페어링 링크를 붙여넣고 서버를 확인하세요. 링크는 5분 동안 한 번만 사용할 수 있습니다.","copyPairing": "페어링 링크 복사","copied": "복사됨",- "windowHint": "작업은 표시된 탭 그룹에서 실행됩니다. 기존 탭에는 권한이 필요합니다.",+ "windowHint": "작업은 별도의 Chrome 작업 창에서 실행됩니다. 기존 탭을 빌리려면 권한이 필요합니다.","preview": "로컬 브라우저 미리보기","waiting": "작업 페이지를 기다리는 중",- "startHint": "브라우저 작업을 보내면 백그라운드에 작업 탭을 만듭니다.",+ "startHint": "브라우저 요청을 보내면 별도의 작업 창이 생성됩니다.","revoke": "기기 인증 취소","revokeConfirm": "취소하면 다시 연결해야 로컬 브라우저를 사용할 수 있습니다.","failed": "작업에 실패했습니다. 다시 시도하세요.",@@ -96,8 +96,10 @@ export default {"reconnectHint": "인증이 저장되어 있습니다. Chrome과 확장 프로그램을 열면 자동으로 다시 연결됩니다.","replaceDevice": "브라우저 변경","installExtension": "BrowserSkill 설치",- "installHint": "이 서버용 확장 프로그램을 다운로드하여 Chrome에 설치하세요.",- "downloadExtension": "확장 프로그램 다운로드",+ "installHint": "현재 서버와 호환되는 패키지를 권장합니다. 공식 스토어에는 업데이트가 늦게 반영될 수 있습니다.",+ "downloadExtension": "호환 패키지 다운로드",+ "officialExtension": "공식 확장 프로그램 (Chrome 웹 스토어)",+ "installGuide": "다운로드한 패키지는 어떻게 설치하나요?","pairBrowser": "브라우저 연결","packageUnavailable": "관리자에게 호환되는 확장 프로그램 패키지를 요청하세요.","manualCopy": "아래 링크를 복사하세요. 5분 동안 한 번만 사용할 수 있습니다.",@@ -105,11 +107,11 @@ export default {"copyAgain": "다시 복사","usageTitle": "사용 방법","usageStep1Title": "확장 프로그램 설치",- "usageStep1Text": "확장 압축을 풀고 Chrome 확장 프로그램 페이지에서 개발자 모드를 켜 로드하세요.",+ "usageStep1Text": "ZIP 파일의 압축을 풀고 Chrome 주소창에 chrome://extensions를 입력하세요. 개발자 모드를 켜고 압축해제된 확장 프로그램을 로드합니다를 선택한 뒤 압축을 푼 확장 프로그램 폴더를 선택하세요.","usageStep2Title": "브라우저 연결",- "usageStep2Text": "페어링 링크를 복사해 확장 프로그램의 원격 연결에 붙여넣고 서버를 확인하세요. 한 번 연결하면 공간 내 모든 대화에서 공유됩니다.",+ "usageStep2Text": "페어링 링크를 확장 프로그램의 연결 설정 → 원격 연결에 붙여넣고 서버를 확인하세요. 한 번 연결하면 공간 내 모든 대화에서 공유됩니다.","usageStep3Title": "대화에서 작업 요청",- "usageStep3Text": "입력창에서 로컬 브라우저를 켜고 웹 작업을 요청하세요. 표시된 탭 그룹에서 실행됩니다.",+ "usageStep3Text": "웹 작업을 보내기 전에 대화 입력창에서 로컬 브라우저를 켜세요. 페어링만으로 자동 활성화되지는 않습니다. 작업은 별도의 작업 창에서 실행됩니다.","usageStep4Title": "미리보기로 확인하고 이어가기","usageStep4Text": "대화에 작은 미리보기가 나타납니다. 클릭하면 작업 탭으로 이동합니다. 중단된 작업은 다시 연결해도 일시정지 상태이므로 미리보기에서 계속하세요. 기존 탭에는 권한이 필요합니다.","running": "실행 중",diff --git a/frontend/src/i18n/locales/ru-RU.ts b/frontend/src/i18n/locales/ru-RU.tsindex 57f68a8a0..2888e14ff 100755--- a/frontend/src/i18n/locales/ru-RU.ts+++ b/frontend/src/i18n/locales/ru-RU.ts@@ -78,13 +78,13 @@ export default {"pause": "Приостановить браузер","start": "Начать задачу","stop": "Завершить задачу браузера",- "pairHint": "Вставьте ссылку в раздел удалённого подключения расширения и проверьте сервер.",+ "pairHint": "Откройте в расширении «Настройки подключения → Удалённое подключение», вставьте ссылку и подтвердите сервер. Ссылка действует 5 минут и используется один раз.","copyPairing": "Скопировать ссылку","copied": "Скопировано",- "windowHint": "Задачи работают в отмеченной группе вкладок. Для существующих вкладок требуется разрешение.",+ "windowHint": "Задачи выполняются в отдельном окне Chrome. Заимствование существующих вкладок требует вашего разрешения.","preview": "Предпросмотр локального браузера","waiting": "Ожидание страницы задачи",- "startHint": "Запрос браузера создаёт фоновые вкладки задачи.",+ "startHint": "Запрос к браузеру создаёт отдельное окно агента.","revoke": "Отозвать доступ устройства","revokeConfirm": "После отзыва потребуется повторное подключение, чтобы снова использовать локальный браузер.","failed": "Операция не удалась. Повторите попытку.",@@ -96,8 +96,10 @@ export default {"reconnectHint": "Авторизация сохранена. Откройте Chrome и BrowserSkill для автоматического подключения.","replaceDevice": "Сменить браузер","installExtension": "Установите BrowserSkill",- "installHint": "Скачайте расширение для этого сервера и установите в Chrome.",- "downloadExtension": "Скачать расширение",+ "installHint": "Рекомендуем пакет для этого сервера: обновления в официальном магазине могут появляться позже.",+ "downloadExtension": "Скачать совместимый пакет",+ "officialExtension": "Официальное расширение (Интернет-магазин Chrome)",+ "installGuide": "Как установить скачанный пакет?","pairBrowser": "Подключите браузер","packageUnavailable": "Запросите совместимое расширение у администратора.","manualCopy": "Скопируйте ссылку ниже. Она действует 5 минут и используется один раз.",@@ -105,11 +107,11 @@ export default {"copyAgain": "Копировать ещё раз","usageTitle": "Как пользоваться","usageStep1Title": "Установите расширение",- "usageStep1Text": "Распакуйте пакет, включите режим разработчика на странице расширений Chrome и загрузите папку.",+ "usageStep1Text": "Распакуйте ZIP, введите chrome://extensions в адресной строке Chrome, включите режим разработчика, нажмите «Загрузить распакованное расширение» и выберите папку расширения.","usageStep2Title": "Подключите браузер",- "usageStep2Text": "Скопируйте ссылку и вставьте её в раздел удалённого подключения расширения. Одно подключение используется во всех диалогах пространства.",+ "usageStep2Text": "Вставьте ссылку в «Настройки подключения → Удалённое подключение» расширения и подтвердите сервер. Одно подключение используется во всех диалогах пространства.","usageStep3Title": "Опишите задачу в диалоге",- "usageStep3Text": "Включите локальный браузер в поле ввода и опишите веб-задачу. Она выполняется в отмеченной группе вкладок.",+ "usageStep3Text": "Перед отправкой веб-задачи включите локальный браузер в поле ввода диалога. Подключение не включает эту опцию автоматически. Задачи выполняются в отдельном окне агента.","usageStep4Title": "Просматривайте и продолжайте через предпросмотр","usageStep4Text": "В диалоге появится миниатюра. Нажмите её, чтобы перейти к вкладке задачи. Прерванные задачи остаются на паузе после переподключения — продолжите через предпросмотр. Для существующих вкладок нужно разрешение.","running": "Выполняется",diff --git a/frontend/src/i18n/locales/zh-CN.ts b/frontend/src/i18n/locales/zh-CN.tsindex 81f3dfa3f..a93a932d9 100755--- a/frontend/src/i18n/locales/zh-CN.ts+++ b/frontend/src/i18n/locales/zh-CN.ts@@ -78,13 +78,13 @@ export default {"pause": "暂停操作","start": "开始任务","stop": "结束浏览器任务",- "pairHint": "在扩展的「远程连接」中粘贴配对链接,确认服务器后连接。",+ "pairHint": "打开扩展的「连接设置 → 远程连接」,粘贴配对链接并确认服务器。链接 5 分钟内有效,仅可使用一次。","copyPairing": "复制配对链接","copied": "已复制",- "windowHint": "任务在 Chrome 的 WeKnora 标签组内运行。借用已有标签页需确认。",+ "windowHint": "任务在独立的 Chrome 任务窗口中运行。借用已有标签页需要你的授权。","preview": "本机浏览器任务预览","waiting": "等待任务页面",- "startHint": "发送浏览器任务后,会在后台创建带标识的任务标签。",+ "startHint": "发起浏览器请求后,会创建独立的任务窗口。","revoke": "撤销设备授权","revokeConfirm": "撤销后需要重新配对,才能继续使用本机浏览器。","failed": "操作失败,请重试",@@ -96,8 +96,10 @@ export default {"reconnectHint": "保留授权,等待扩展自动重连。请确认 Chrome 和 BrowserSkill 扩展已开启。","replaceDevice": "更换浏览器","installExtension": "安装 BrowserSkill 扩展",- "installHint": "下载与当前服务配套的扩展,安装到 Chrome。",- "downloadExtension": "下载扩展",+ "installHint": "建议使用与当前服务匹配的配套扩展;官方商店版本可能稍晚更新。",+ "downloadExtension": "下载配套扩展",+ "officialExtension": "官方扩展(Chrome 应用商店)",+ "installGuide": "如何安装下载的扩展包?","pairBrowser": "连接这台浏览器","packageUnavailable": "管理员尚未配置扩展下载包,请向管理员获取配套版本。","manualCopy": "点击下方输入框复制链接,5 分钟内有效,仅可配对一次。",@@ -105,11 +107,11 @@ export default {"copyAgain": "再次复制","usageTitle": "使用方式","usageStep1Title": "安装扩展",- "usageStep1Text": "解压扩展包,在 Chrome 的扩展程序页面开启开发者模式,选择「加载已解压的扩展程序」。",+ "usageStep1Text": "下载 ZIP 后解压,在 Chrome 地址栏输入 chrome://extensions,开启「开发者模式」,点击「加载已解压的扩展程序」,选择解压后的扩展目录。","usageStep2Title": "配对这台浏览器",- "usageStep2Text": "复制配对链接,在扩展的「远程连接」中粘贴并确认服务器。配对一次,同一空间的各个对话共用。",+ "usageStep2Text": "复制配对链接,在扩展的「连接设置 → 远程连接」中粘贴并确认服务器。配对一次,同一空间的各个对话共用。","usageStep3Title": "回到对话描述任务",- "usageStep3Text": "在输入栏打开本机浏览器,直接描述要完成的网页任务。任务会在带标识的标签组中运行。",+ "usageStep3Text": "在对话输入栏开启「本机浏览器」,再发送网页任务。配对不会自动开启此选项,任务会在独立的任务窗口中运行。","usageStep4Title": "通过预览查看和继续","usageStep4Text": "对话里会出现小预览,点击可定位到任务标签。中断或重连后任务仍会暂停,请在预览中点继续;借用已有标签页会先请你确认。","running": "运行中",diff --git a/frontend/src/views/settings/BrowserConnectionSettings.vue b/frontend/src/views/settings/BrowserConnectionSettings.vueindex 20dfdccf7..20c14af12 100644--- a/frontend/src/views/settings/BrowserConnectionSettings.vue+++ b/frontend/src/views/settings/BrowserConnectionSettings.vue@@ -61,6 +61,16 @@<div class="step-copy"><strong>{{ t('localBrowser.installExtension') }}</strong><p>{{ t('localBrowser.installHint') }}</p>+ <a class="official-extension-link"+ href="https://chromewebstore.google.com/detail/hhcmgoofomhgciiibhipgmgkgnoenaoi"+ target="_blank" rel="noopener noreferrer">+ {{ t('localBrowser.officialExtension') }}+ <t-icon name="jump" size="14px" />+ </a>+ <details class="install-guide">+ <summary>{{ t('localBrowser.installGuide') }}</summary>+ <p>{{ t('localBrowser.usageStep1Text') }}</p>+ </details></div><t-button theme="default" variant="outline" size="small":disabled="!status.extension_available || downloading" @click="download">@@ -425,6 +435,34 @@ onBeforeUnmount(() => { alive = false; controller.abort(); clearTimeout(timer);color: var(--td-text-color-secondary);}+.official-extension-link {+ display: inline-flex;+ align-items: center;+ gap: 4px;+ margin-top: 4px;+ color: var(--td-brand-color);+ font-size: var(--app-text-sm);+ line-height: 1.6;+ text-decoration: none;++ &:hover,+ &:focus-visible {+ text-decoration: underline;+ }+}++.install-guide {+ margin-top: 6px;+ color: var(--td-text-color-secondary);+ font-size: var(--app-text-sm);+ line-height: 1.6;++ summary {+ cursor: pointer;+ width: fit-content;+ }+}+.pairing-feedback {margin-top: 16px;padding: 10px 12px;diff --git a/internal/agent/tools/browserskill_prompt.go b/internal/agent/tools/browserskill_prompt.goindex 63f5dae2f..0043f72ef 100644--- a/internal/agent/tools/browserskill_prompt.go+++ b/internal/agent/tools/browserskill_prompt.go@@ -75,11 +75,16 @@ Task tabs:- tab_list scope=user means not authorized for this task. Call tab_borrow beforetab_select, reading, request_help or other operations on such a tab. Listing a tabdoes not authorize it. Follow extension confirmation and return borrowed tabs when done.-- New tabs opened directly by your action on a controlled page belong to this task when- the extension can verify their source. List tabs and use the returned tab_id to continue.+- New tabs opened by native click/key input within the Agent Window can be controlled+ when the extension verifies their source. They are observed tabs, preserved at task end.+ Separate popup windows and unattributed tabs require tab_borrow before content access.+ List tabs and use the returned tab_id; never infer authorization from window membership.- If a tab is unauthorized, call tab_borrow once and let the extension request approval;- this also works inside the task window. Never ask the user to move it out merely to borrow.- During borrowing, the user must approve in the target page's BrowserSkill confirmation.+ an unowned tab already inside the Agent Window must first be moved by the user to a+ regular browser window. For a lookup that does not need its live state, navigate in an+ owned task tab instead. Borrow confirmation appears on a regular browser window's+ HTTP(S) page; if no page can display it, ask the user to open one before retrying.+ Follow the extension's browser-controlled confirmation preference.A denied or timed-out borrow requires user intervention, not repeated select/read/closeor request_help attempts. Continue operation only resumes a paused task; it does notapprove borrowing. After explicit resume, a fresh borrow still needs browser approval.diff --git a/internal/agent/tools/browserskill_result.go b/internal/agent/tools/browserskill_result.goindex 0677b8010..6894a0e12 100644--- a/internal/agent/tools/browserskill_result.go+++ b/internal/agent/tools/browserskill_result.go@@ -29,19 +29,30 @@ func browserRecoveryHint(method string, err *browserskill.RPCError) string {Effect string `json:"effect_state"`}_ = json.Unmarshal(err.Data, &data)+ if method == "tab_borrow" && data.Reason == "confirmation_ui_unavailable" {+ return "Ask the user to open an HTTP(S) page in a regular browser window so BrowserSkill can " ++ "display the borrow confirmation, then request tab_borrow again. Task windows, separate " ++ "popups and extension settings cannot host that confirmation. Do not retry until a page is available."+ }+ if method == "tab_borrow" && err.Code == "invalid_params" &&+ strings.Contains(err.Message, "not authorized and already lives in the Agent Window") {+ return "Ask the user to move this unowned tab to a regular browser window before calling " ++ "tab_borrow again. If its live state is unnecessary, navigate in an owned task tab instead. " ++ "Being inside the Agent Window does not authorize access."+ }if method == "tab_borrow" && (data.Reason == "confirmation_timeout" ||err.Code == "timeout" || err.Code == "cancelled" || err.Code == "user_aborted") {return "Stop browser actions: tab borrowing was not approved. The confirmation is no longer pending. " +"Ask the user to click Continue operation in the conversation preview " +"before continuing in this same conversation. " +"Continue operation only resumes the task; it does not grant tab access. After explicit resume, " +- "request tab_borrow once again and wait for Allow in the target page's BrowserSkill confirmation. " ++ "request tab_borrow once again and wait for Allow in the browser's BrowserSkill confirmation. " +"Do not call request_help on the unapproved tab or reconnect/pair again."}if err.Code == "permission_denied" && (strings.Contains(err.Message, "borrow this tab before") ||strings.Contains(err.Message, "Authorize this tab with tab_borrow")) {return "This tab is not authorized for the current task. If its existing page state is needed, " +- "call tab_borrow once and wait for the user's approval in the target page. " ++ "call tab_borrow once and follow the extension's browser-controlled approval flow. " +"Do not retry tab_select/read/close or call request_help before borrowing succeeds. " +"For an ordinary website lookup that does not need this tab's state, navigate in the task's own tab."}@@ -72,6 +83,11 @@ func browserRecoveryHint(method string, err *browserskill.RPCError) string {case "target_not_select", "option_not_found", "single_select_value_count":return "select requires a native select and its option values. Inspect current options; " +"use click/observe for a custom dropdown."+ case "renderer_read_timeout":+ return "A browser read is unavailable and further reads may be refused while it is still pending. " ++ "Do not repeat snapshot/observe on this tab. Navigation alone does not clear the pending read; " ++ "it must settle or its debugger session detach. Switch to another tab, or finish the turn " ++ "and report the unavailable read."case "agent_window_scope", "borrow_conflict":return "List actual user tabs and respect tab ownership. Borrow the intended available tab " +"through extension confirmation; never guess its ID."diff --git a/internal/agent/tools/browserskill_result_test.go b/internal/agent/tools/browserskill_result_test.goindex 43c124c08..e2050f3c5 100644--- a/internal/agent/tools/browserskill_result_test.go+++ b/internal/agent/tools/browserskill_result_test.go@@ -159,6 +159,19 @@ func TestBorrowRecoveryDoesNotConfuseResumeWithApproval(t *testing.T) {require.Contains(t, hint, "does not grant tab access")require.Contains(t, hint, "After explicit resume")require.Contains(t, hint, "Do not call request_help")+ hint = browserRecoveryHint("tab_borrow", &browserskill.RPCError{+ Code: "unsupported", Message: "No user tab can display the borrow confirmation",+ Data: json.RawMessage(`{"reason":"confirmation_ui_unavailable"}`),+ })+ require.Contains(t, hint, "HTTP(S) page in a regular browser window")+ require.Contains(t, hint, "Do not retry until a page is available")+ hint = browserRecoveryHint("tab_borrow", &browserskill.RPCError{+ Code: "invalid_params",+ Message: "tab_borrow: tab 7 is not authorized and already lives in the Agent Window; " ++ "move it to a regular browser window, then borrow it",+ })+ require.Contains(t, hint, "Ask the user to move")+ require.Contains(t, hint, "navigate in an owned task tab")// Unrelated permission denials must not suggest a way to borrow around them.hint = browserRecoveryHint("click", &browserskill.RPCError{Code: "permission_denied", Message: "policy denied"})require.NotContains(t, hint, "call tab_borrow")diff --git a/internal/browserskill/extension_test.go b/internal/browserskill/extension_test.goindex c233ab8a0..1be05b6ac 100644--- a/internal/browserskill/extension_test.go+++ b/internal/browserskill/extension_test.go@@ -163,7 +163,7 @@ func TestRealExtension(t *testing.T) {}}()if err = json.NewEncoder(input).Encode(map[string]string{- "pairing": link, "extension": extension,+ "pairing": link, "extension": extension, "fixture": fixture.URL,"chromium": os.Getenv("BROWSERSKILL_TEST_CHROMIUM"),"playwright": os.Getenv("BROWSERSKILL_TEST_PLAYWRIGHT"),}); err != nil {@@ -309,20 +309,92 @@ func TestRealExtension(t *testing.T) {t.Fatalf("action result missing: %s", snap)}checkBackground()- // Agent-created navigation targets remain usable throughout their lifecycle.- // Cover both noopener links and script-created popup windows.- for _, selector := range []string{"#new-tab", "#popup"} {- if _, err = call(ctx, scope, "chat", "click", map[string]any{"selector": selector}); err != nil {+ hostAck := func(command, expected string) {+ t.Helper()+ if _, err := fmt.Fprintln(input, command); err != nil {+ t.Fatal(err)+ }+ select {+ case line := <-hostLines:+ if line != expected {+ t.Fatalf("browser host %s: %s", command, line)+ }+ case <-ctx.Done():+ t.Fatal(ctx.Err())+ }+ }+ assertDenied := func(tabID int) {+ t.Helper()+ for _, method := range []string{"tab_select", "snapshot", "tab_close"} {+ _, err := call(ctx, scope, "chat", method, map[string]any{"tab_id": tabID})+ if err == nil || !strings.Contains(err.Error(), "permission_denied") {+ t.Fatalf("unauthorized tab %d accepted %s: %v", tabID, method, err)+ }+ }+ }+ borrowTab := func(tabID int) {+ t.Helper()+ done := make(chan error, 1)+ go func() {+ _, err := call(ctx, scope, "chat", "tab_borrow", map[string]any{"tab_id": tabID})+ done <- err+ }()+ for !m.Status(scope, "chat").NeedsHelp {+ select {+ case err := <-done:+ t.Fatalf("borrow finished without browser confirmation: %v", err)+ case <-tick.C:+ case <-ctx.Done():+ t.Fatal(ctx.Err())+ }+ }+ if m.Status(scope, "chat").Action != "tab_borrow" {+ t.Fatal("borrow confirmation must identify its handoff separately from login help")+ }+ hostAck("approve-borrow", "approve-borrow-done")+ select {+ case err := <-done:+ if err != nil {+ t.Fatal(err)+ }+ case <-ctx.Done():+ t.Fatal(ctx.Err())+ }+ }+ returnTab := func(tabID int) {+ t.Helper()+ hostAck(fmt.Sprintf("before-tab-return %d", tabID), "return-recorded")+ result, err := call(ctx, scope, "chat", "tab_return", map[string]any{"tab_id": tabID})+ if err != nil {+ t.Fatal(err)+ }+ var compact bytes.Buffer+ if err := json.Compact(&compact, result); err != nil {+ t.Fatal(err)+ }+ hostAck("expect-returned-tab "+compact.String(), "returned-tab-preserved")+ assertDenied(tabID)+ }+ // Same-window navigation targets are observed; independent popup windows+ // require the official borrow/return flow, even when opened by native input.+ for _, target := range []struct {+ selector string+ path string+ borrow bool+ }{+ {"#new-tab", "/linked", false},+ {"#popup", "/popup", true},+ } {+ t.Logf("navigation target %s (borrow=%t)", target.selector, target.borrow)+ if _, err = call(ctx, scope, "chat", "click", map[string]any{"selector": target.selector}); err != nil {t.Fatal(err)}popupID := 0- var e error- deadline := time.NewTimer(3 * time.Second)- waitPopup:+ deadline := time.After(3 * time.Second)for popupID == 0 {- listed, listErr := call(ctx, scope, "chat", "tab_list", map[string]any{"scope": "all"})- if listErr != nil {- t.Fatal(listErr)+ listed, err := call(ctx, scope, "chat", "tab_list", map[string]any{"scope": "all"})+ if err != nil {+ t.Fatal(err)}var result struct {Tabs []struct {@@ -330,38 +402,50 @@ func TestRealExtension(t *testing.T) {URL string `json:"url"`} `json:"tabs"`}- if e = json.Unmarshal(listed, &result); e != nil {- t.Fatal(e)+ if err := json.Unmarshal(listed, &result); err != nil {+ t.Fatal(err)}for _, tab := range result.Tabs {- if strings.HasSuffix(tab.URL, "/linked") || strings.HasSuffix(tab.URL, "/popup") {+ if tab.URL == fixture.URL+target.path {popupID = tab.ID}}if popupID != 0 {- break waitPopup+ break}select {case <-tick.C:- case <-deadline.C:+ case <-deadline:t.Fatalf("fixture popup missing: %s", listed)case <-ctx.Done():t.Fatal(ctx.Err())}}- deadline.Stop()- if _, e = call(ctx, scope, "chat", "tab_select", map[string]any{"tab_id": popupID}); e != nil {- t.Fatal(e)+ if target.borrow {+ assertDenied(popupID)+ borrowTab(popupID)}- if _, e = call(ctx, scope, "chat", "snapshot", map[string]any{"tab_id": popupID}); e != nil {- t.Fatal(e)+ if _, err = call(ctx, scope, "chat", "tab_select", map[string]any{"tab_id": popupID}); err != nil {+ t.Fatal(err)}- if _, e = call(ctx, scope, "chat", "tab_close", map[string]any{"tab_id": popupID}); e != nil {- t.Fatal(e)+ if _, err = call(ctx, scope, "chat", "snapshot", map[string]any{"tab_id": popupID}); err != nil {+ t.Fatal(err)+ }+ if target.borrow {+ if _, err = call(ctx, scope, "chat", "tab_close", map[string]any{"tab_id": popupID}); err == nil ||+ !strings.Contains(err.Error(), "invalid_params") {+ t.Fatalf("borrowed popup was closable: %v", err)+ }+ returnTab(popupID)+ // Keep the returned page: later cleanup checks must prove that+ // task stop preserves it and releases its debugger attachment.+ } else if _, err = call(ctx, scope, "chat", "tab_close", map[string]any{"tab_id": popupID}); err != nil {+ t.Fatal(err)}}- // A genuine user-created tab inside the task window remains unauthorized,- // but can be borrowed there with an actual browser confirmation.+ // A genuine user-created tab inside the task window remains unauthorized and+ // cannot be borrowed in place (upstream PR #297). Once moved to a regular+ // window it can be borrowed with an actual browser confirmation._, _ = io.WriteString(input, "create-unowned-tab\n")var userTab struct {ID int `json:"tab_id"`@@ -380,48 +464,24 @@ func TestRealExtension(t *testing.T) {t.Fatalf("unowned user tab accepted %s: %v", method, err)}}- borrowDone := make(chan error, 1)- go func() {- _, borrowErr := call(ctx, scope, "chat", "tab_borrow", map[string]any{"tab_id": userTab.ID})- borrowDone <- borrowErr- }()- for !m.Status(scope, "chat").NeedsHelp {- select {- case <-tick.C:- case <-ctx.Done():- t.Fatal(ctx.Err())- }- }- if m.Status(scope, "chat").Action != "tab_borrow" {- t.Fatal("borrow confirmation must identify its handoff separately from login help")+ if _, err = call(ctx, scope, "chat", "tab_borrow", map[string]any{"tab_id": userTab.ID}); err == nil ||+ !strings.Contains(err.Error(), "invalid_params") {+ t.Fatalf("unowned tab inside the Agent Window was borrowed in place: %v", err)}- _, _ = io.WriteString(input, "approve-borrow\n")+ _, _ = fmt.Fprintf(input, "move-fixture-tab-out %d\n", userTab.ID)select {case line := <-hostLines:- if line != "approve-borrow-done" {- t.Fatalf("borrow confirmation: %s", line)- }- case <-ctx.Done():- t.Fatal(ctx.Err())- }- select {- case err = <-borrowDone:- if err != nil {- t.Fatal(err)+ if line != "fixture-tab-moved" {+ t.Fatalf("move fixture tab: %s", line)}case <-ctx.Done():t.Fatal(ctx.Err())}+ borrowTab(userTab.ID)if _, err = call(ctx, scope, "chat", "snapshot", map[string]any{"tab_id": userTab.ID}); err != nil {t.Fatal(err)}- if _, err = call(ctx, scope, "chat", "tab_return", map[string]any{"tab_id": userTab.ID}); err != nil {- t.Fatal(err)- }- if _, err = call(ctx, scope, "chat", "snapshot", map[string]any{"tab_id": userTab.ID}); err == nil ||- !strings.Contains(err.Error(), "permission_denied") {- t.Fatalf("returned tab remained readable: %v", err)- }+ returnTab(userTab.ID)_, _ = fmt.Fprintf(input, "remove-fixture-tab %d\n", userTab.ID)select {case line := <-hostLines:@@ -743,7 +803,7 @@ func TestRealExtension(t *testing.T) {select {case line := <-hostLines:if line != `{"cleaned":true}` {- t.Fatalf("browser task leaked tabs or groups: %s", line)+ t.Fatalf("browser cleanup changed user tabs or leaked task tabs: %s", line)}case <-ctx.Done():t.Fatal(ctx.Err())@@ -816,8 +876,8 @@ func TestRealExtension(t *testing.T) {t.Fatal(err)}checkCleanup()- // Repeated successful turns must return to the original user tabs, with- // no live task groups left over. The next turn can start without Resume.+ // Repeated successful turns preserve the original and returned user tabs,+ // with no agent-created tabs left over. The next turn needs no Resume.for round := range 3 {t.Logf("automatic cleanup round %d", round+1)if err = m.Control(ctx, scope, "chat", "select"); err != nil {diff --git a/internal/browserskill/focus.go b/internal/browserskill/focus.goindex 9fe74ae4b..63d68806b 100644--- a/internal/browserskill/focus.go+++ b/internal/browserskill/focus.go@@ -12,9 +12,12 @@ type uiReply struct {err error}+// Extensions without the optional UI channel (BrowserSkill main after PR #296)+// route ui.* requests to the native dispatcher, which answers unknown_method.var errGatewayUIUnsupported = &RPCError{- Code: "gateway_ui_unsupported",- Message: "BrowserSkill extension lacks WeKnora task controls; install the companion extension",+ Code: "gateway_ui_unsupported",+ Message: "BrowserSkill extension lacks the ui.task_preview/ui.task_focus channel; " ++ "install the extension built from the pinned baseline",}// Focus is user initiated. Only the server-owned task ID is sent to Chrome.@@ -22,7 +25,7 @@ func (m *Manager) Focus(ctx context.Context, s Scope, session string) error {if _, remote, err := m.route(ctx, s, session, "focus", "", nil); remote || err != nil {return err}- data, err := m.callUI(ctx, s, session, "gateway.task_focus")+ data, err := m.callUI(ctx, s, session, "ui.task_focus")if err != nil {return err}diff --git a/internal/browserskill/manager.go b/internal/browserskill/manager.goindex f47f872b9..0b693c9f0 100644--- a/internal/browserskill/manager.go+++ b/internal/browserskill/manager.go@@ -17,6 +17,7 @@ import ("net/url""os""path/filepath"+ "slices""strings""sync""time"@@ -710,6 +711,95 @@ func rpc(ctx context.Context, d *device, method string, params any) (json.RawMesreturn reply.Result, nil}+// agentWindowTabs lists every tab in the task's Agent Window, including tabs+// the browser user opened there; any of them keeps the window alive.+func agentWindowTabs(ctx context.Context, d *device, session string) ([]float64, error) {+ list, err := rpc(ctx, d, "tool.tab_list", map[string]any{"session_id": session, "scope": "agent"})+ if err != nil {+ return nil, err+ }+ var listed struct {+ Tabs []struct {+ ID float64 `json:"tab_id"`+ } `json:"tabs"`+ }+ if json.Unmarshal(list, &listed) != nil {+ return nil, errors.New("invalid BrowserSkill tab list")+ }+ ids := make([]float64, 0, len(listed.Tabs))+ for _, tab := range listed.Tabs {+ ids = append(ids, tab.ID)+ }+ return ids, nil+}++// preserveAgentWindow keeps a retained task's Agent Window open when the agent+// closes its last tab there. Chrome removes a window together with its final+// tab, and the extension reports that removal as a user-closed window, which+// would pause the task and drop its session. A blank tab created through the+// native tab_create RPC is agent-owned, so session stop closes it with the+// other agent tabs. Only official RPCs are used; the extension needs no patch.+// It returns the placeholder's tab ID, or 0 when none was needed.+func preserveAgentWindow(ctx context.Context, d *device, session string, tabID any) (float64, error) {+ target, ok := numericID(tabID)+ if !ok {+ return 0, nil // The extension reports the invalid parameter itself.+ }+ tabs, err := agentWindowTabs(ctx, d, session)+ if err != nil {+ return 0, err+ }+ if len(tabs) != 1 || tabs[0] != target {+ return 0, nil+ }+ created, err := rpc(ctx, d, "tool.tab_create", map[string]any{+ "session_id": session, "url": "about:blank", "active": false,+ })+ if err != nil {+ return 0, err+ }+ var placeholder struct {+ ID float64 `json:"tab_id"`+ }+ if json.Unmarshal(created, &placeholder) != nil || placeholder.ID == 0 {+ return 0, errors.New("invalid BrowserSkill tab_create result")+ }+ return placeholder.ID, nil+}++// releasePlaceholder undoes preserveAgentWindow after tab_close failed or was+// interrupted, so a refused close (unauthorized or borrowed tab) does not leave+// an extra agent-owned blank tab behind. The extension may have closed the+// target before the reply was lost, in which case the placeholder is the tab+// keeping the Agent Window open: it is removed only while the target still+// exists. Best effort with its own deadline, since the failed call's context+// may already be cancelled.+func releasePlaceholder(d *device, session string, tabID any, placeholder float64) {+ target, _ := numericID(tabID)+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)+ defer cancel()+ tabs, err := agentWindowTabs(ctx, d, session)+ if err != nil || !slices.Contains(tabs, target) {+ return+ }+ _, _ = rpc(ctx, d, "tool.tab_close", map[string]any{"session_id": session, "tab_id": placeholder})+}++func numericID(v any) (float64, bool) {+ switch n := v.(type) {+ case float64:+ return n, true+ case int:+ return float64(n), true+ case int64:+ return float64(n), true+ case json.Number:+ f, err := n.Float64()+ return f, err == nil+ }+ return 0, false+}+var methods = map[string]bool{"snapshot": true,"observe": true,@@ -873,7 +963,18 @@ func (m *Manager) Call(clean["timeout_ms"] = humanTimeoutMS(clean["timeout_ms"])}}- result, err := rpc(callCtx, d, "tool."+method, clean)+ var result json.RawMessage+ var err error+ var placeholder float64+ if method == "tab_close" {+ placeholder, err = preserveAgentWindow(callCtx, d, id, clean["tab_id"])+ }+ if err == nil {+ result, err = rpc(callCtx, d, "tool."+method, clean)+ if err != nil && placeholder != 0 {+ releasePlaceholder(d, id, clean["tab_id"], placeholder)+ }+ }if method == "request_help" && err == nil {var help struct {Outcome string `json:"outcome"`@@ -1146,7 +1247,7 @@ func (m *Manager) Preview(ctx context.Context, s Scope, session string) (json.Raid := t.idd.mu.Unlock()defer func() { d.mu.Lock(); t.previewBusy = false; d.mu.Unlock() }()- frame, err := m.callUI(ctx, s, session, "gateway.task_preview")+ frame, err := m.callUI(ctx, s, session, "ui.task_preview")if err != nil {return nil, err}diff --git a/internal/browserskill/shared_test.go b/internal/browserskill/shared_test.goindex 85c578ae5..34d622a78 100644--- a/internal/browserskill/shared_test.go+++ b/internal/browserskill/shared_test.go@@ -6,6 +6,7 @@ import ("net/http""net/http/httptest""os"+ "slices""strings""sync""sync/atomic"@@ -161,9 +162,9 @@ func connectSharedFixture(return}result = map[string]any{"cancelled": true}- case "gateway.task_preview":+ case "ui.task_preview":result = map[string]any{"image_base64": "dGVzdA==", "format": "jpeg"}- case "gateway.task_focus":+ case "ui.task_focus":result = map[string]any{"focused": true}case "system.ping":result = map[string]any{"pong": true}@@ -736,7 +737,7 @@ func TestFinishTurnUsesOfficialLifecycleWithoutGatewayCalls(t *testing.T) {connectSharedFixture(ctx, t, owner, scope, "", "browser", func(f *sharedFixture, id, method string, _ map[string]any,) bool {- if !strings.HasPrefix(method, "gateway.") {+ if !strings.HasPrefix(method, "ui.") {return false}gatewayCalls.Add(1)@@ -831,3 +832,111 @@ func TestBorrowConfirmationBudgetReachesExtension(t *testing.T) {})}}++func TestAgentClosingLastTabKeepsAgentWindow(t *testing.T) {+ m, ctx := sharedTestManager(t)+ s := Scope{1, "last-tab"}+ var mu sync.Mutex+ var methods []string+ var created []map[string]any+ var closeError string // error code the fixture returns when closing tab 9+ var closeDrops bool // the extension closed the tab before failing the reply+ tabs := []map[string]any{{"tab_id": 7, "window_id": 100, "scope": "agent"}}+ removeTab := func(id any) {+ want, _ := numericID(id)+ tabs = slices.DeleteFunc(tabs, func(tab map[string]any) bool {+ got, _ := numericID(tab["tab_id"])+ return got == want+ })+ }+ connectSharedFixture(ctx, t, m, s, "", "browser", func(+ f *sharedFixture, id, method string, params map[string]any,+ ) bool {+ mu.Lock()+ defer mu.Unlock()+ var result any+ switch method {+ case "tool.tab_list":+ if params["scope"] != "agent" {+ _ = f.send(map[string]any{"id": id, "error": map[string]string{+ "code": "invalid_params", "message": "fixture expects the agent scope",+ }})+ return true+ }+ result = map[string]any{"tabs": append([]map[string]any(nil), tabs...)}+ case "tool.tab_create":+ created = append(created, params)+ tabs = append(tabs, map[string]any{"tab_id": 8, "window_id": 100, "scope": "agent"})+ result = map[string]any{"tab_id": 8, "window_id": 100, "url": "about:blank"}+ case "tool.tab_close":+ methods = append(methods, fmt.Sprintf("tool.tab_close:%v", params["tab_id"]))+ if target, _ := numericID(params["tab_id"]); closeError != "" && target == 9 {+ if closeDrops {+ removeTab(params["tab_id"])+ }+ _ = f.send(map[string]any{"id": id, "error": map[string]string{+ "code": closeError, "message": "fixture refused",+ }})+ return true+ }+ removeTab(params["tab_id"])+ _ = f.send(map[string]any{"id": id, "result": map[string]any{"tab_id": params["tab_id"]}})+ return true+ default:+ return false+ }+ methods = append(methods, method)+ _ = f.send(map[string]any{"id": id, "result": result})+ return true+ })+ require.NoError(t, m.Control(ctx, s, "chat", "select"))+ // The final agent tab gets a blank replacement so Chrome keeps the window.+ _, err := m.Call(ctx, s, "chat", "tab_close", map[string]any{"tab_id": float64(7)})+ require.NoError(t, err)+ mu.Lock()+ require.Equal(t, []string{"tool.tab_list", "tool.tab_create", "tool.tab_close:7"}, methods)+ require.Len(t, created, 1)+ require.Equal(t, "about:blank", created[0]["url"])+ require.Equal(t, false, created[0]["active"])+ require.NotEmpty(t, created[0]["session_id"])+ methods = nil+ tabs = []map[string]any{+ {"tab_id": 8, "window_id": 100, "scope": "agent"},+ {"tab_id": 9, "window_id": 100, "scope": "user"},+ }+ mu.Unlock()+ // Any other tab in the Agent Window, even a user's, keeps it open.+ _, err = m.Call(ctx, s, "chat", "tab_close", map[string]any{"tab_id": 8})+ require.NoError(t, err)+ mu.Lock()+ require.Equal(t, []string{"tool.tab_list", "tool.tab_close:8"}, methods)+ // A refused close (unauthorized or borrowed tab) must not leave the+ // placeholder behind: the target is still there, so the blank tab goes.+ methods, created = nil, nil+ tabs = []map[string]any{{"tab_id": 9, "window_id": 100, "scope": "agent"}}+ closeError = "permission_denied"+ mu.Unlock()+ _, err = m.Call(ctx, s, "chat", "tab_close", map[string]any{"tab_id": 9})+ require.ErrorContains(t, err, "permission_denied")+ mu.Lock()+ require.Equal(t, []string{+ "tool.tab_list", "tool.tab_create", "tool.tab_close:9", "tool.tab_list", "tool.tab_close:8",+ }, methods)+ require.Len(t, tabs, 1)+ require.Equal(t, 9, tabs[0]["tab_id"])+ require.False(t, m.Status(s, "chat").Paused)+ // When the extension already removed the target before the reply failed,+ // the placeholder is what keeps the window open and must stay.+ methods, created = nil, nil+ closeError, closeDrops = "cdp_failed", true+ mu.Unlock()+ _, err = m.Call(ctx, s, "chat", "tab_close", map[string]any{"tab_id": 9})+ require.ErrorContains(t, err, "cdp_failed")+ mu.Lock()+ require.Equal(t, []string{+ "tool.tab_list", "tool.tab_create", "tool.tab_close:9", "tool.tab_list",+ }, methods)+ require.Len(t, tabs, 1)+ require.Equal(t, 8, tabs[0]["tab_id"])+ mu.Unlock()+}diff --git a/patches/browserskill/01-browser-read-reliability.patch b/patches/browserskill/01-browser-read-reliability.patchdeleted file mode 100644index 2e51adef0..000000000--- a/patches/browserskill/01-browser-read-reliability.patch+++ /dev/null@@ -1,562 +0,0 @@-diff --git a/apps/extension/src/browser-driver/__tests__/chromium-cdp.test.ts b/apps/extension/src/browser-driver/__tests__/chromium-cdp.test.ts-index 8f99c94..16f7499 100644---- a/apps/extension/src/browser-driver/__tests__/chromium-cdp.test.ts-+++ b/apps/extension/src/browser-driver/__tests__/chromium-cdp.test.ts-@@ -30,6 +30,77 @@ function fakeApi() {- }-- describe("ChromiumCdp", () => {-+ it("configures frame auto-attach once per debugger session and reapplies after detach", async () => {-+ const { api, onDetach } = fakeApi();-+ vi.mocked(api.sendCommand).mockResolvedValue({ frameTree: { frame: { id: "main" } } });-+ const cdp = new ChromiumCdp(api);-+ const calls = () =>-+ vi.mocked(api.sendCommand).mock.calls.filter((c) => c[1] === "Target.setAutoAttach");-+ await cdp.ensureAttached(4);-+ await Promise.all([cdp.getFrameGraph(4), cdp.getFrameGraph(4)]);-+ await cdp.getFrameGraph(4);-+ expect(calls()).toHaveLength(1);-+ onDetach.fire({ tabId: 4 }, "canceled_by_user");-+ await cdp.getFrameGraph(4);-+ expect(calls()).toHaveLength(2);-+ await cdp.detachAll();-+ await cdp.getFrameGraph(4);-+ expect(calls()).toHaveLength(3);-+ cdp.dispose();-+ });-+-+ it("retries frame discovery after a failed configuration", async () => {-+ const { api } = fakeApi();-+ let attempts = 0;-+ vi.mocked(api.sendCommand).mockImplementation(async (_target, method) => {-+ if (method === "Target.setAutoAttach" && ++attempts === 1) throw new Error("transient");-+ return { frameTree: { frame: { id: "main" } } };-+ });-+ const cdp = new ChromiumCdp(api);-+ await cdp.ensureAttached(4);-+ await cdp.getFrameGraph(4);-+ await cdp.getFrameGraph(4);-+ expect(attempts).toBe(2);-+ cdp.dispose();-+ });-+-+ it("does not send another screenshot after a local timeout while Chrome is still working", async () => {-+ vi.useFakeTimers();-+ const warning = vi.spyOn(console, "warn").mockImplementation(() => {});-+ const { api } = fakeApi();-+ let finish!: (value: unknown) => void;-+ vi.mocked(api.sendCommand).mockImplementation(async (_target, method) => {-+ if (method === "Page.captureScreenshot")-+ return new Promise((resolve) => {-+ finish = resolve;-+ });-+ return {};-+ });-+ const cdp = new ChromiumCdp(api);-+ try {-+ await cdp.ensureAttached(4);-+ const first = expect(cdp.send(4, "Page.captureScreenshot")).rejects.toThrow("timed out");-+ await vi.advanceTimersByTimeAsync(3000);-+ await first;-+ expect(cdp.hasPendingScreenshot(4)).toBe(true);-+ await expect(cdp.send(4, "Page.captureScreenshot")).rejects.toThrow("still running");-+ expect(-+ vi.mocked(api.sendCommand).mock.calls.filter((c) => c[1] === "Page.captureScreenshot"),-+ ).toHaveLength(1);-+ finish({ data: "late" });-+ await vi.advanceTimersByTimeAsync(0);-+ expect(cdp.hasPendingScreenshot(4)).toBe(false);-+ const next = cdp.send(4, "Page.captureScreenshot");-+ await vi.advanceTimersByTimeAsync(0);-+ finish({ data: "new" });-+ await expect(next).resolves.toEqual({ data: "new" });-+ } finally {-+ cdp.dispose();-+ warning.mockRestore();-+ vi.useRealTimers();-+ }-+ });-+- it("changes attachment identity only across real debugger attachments", async () => {- const { api, onEvent, onDetach } = fakeApi();- const cdp = new ChromiumCdp(api);-@@ -430,6 +501,7 @@ describe("ChromiumCdp", () => {- expect(api.sendCommand).toHaveBeenCalledWith({ tabId: 3 }, "Page.handleJavaScriptDialog", {- accept: true,- });-+ await vi.waitFor(() => expect(cdp.dialogsSince(3, cursor)).toHaveLength(1));- const dialogs = cdp.dialogsSince(3, cursor);- expect(dialogs).toHaveLength(1);- expect(dialogs[0]).toMatchObject({-@@ -479,7 +551,7 @@ describe("ChromiumCdp", () => {- url: "https://example.com/",- });- await Promise.resolve();-- expect(cdp.dialogsSince(11, 0)).toHaveLength(1);-+ await vi.waitFor(() => expect(cdp.dialogsSince(11, 0)).toHaveLength(1));- await cdp.detach(11);- expect(cdp.dialogsSince(11, 0)).toHaveLength(0);- });-diff --git a/apps/extension/src/browser-driver/__tests__/command-deadline.test.ts b/apps/extension/src/browser-driver/__tests__/command-deadline.test.ts-new file mode 100644-index 0000000..7c1dd61---- /dev/null-+++ b/apps/extension/src/browser-driver/__tests__/command-deadline.test.ts-@@ -0,0 +1,76 @@-+import { afterEach, expect, it, vi } from "vitest";-+import { captureObservationFacts } from "@/tools/vom/capture-coordinator";-+import { CdpReadTimeoutError, runCdpCommand } from "../command-deadline";-+-+afterEach(() => {-+ vi.useRealTimers();-+ vi.restoreAllMocks();-+});-+it("times out stuck snapshots with the actual method and stops fallback reads", async () => {-+ vi.useFakeTimers();-+ vi.spyOn(console, "warn").mockImplementation(() => {});-+ vi.spyOn(console, "debug").mockImplementation(() => {});-+ const send = vi.fn(async (_tab: number, method: string) =>-+ runCdpCommand({ tabId: 4 }, method, () =>-+ method === "DOMSnapshot.captureSnapshot" ? new Promise<never>(() => {}) : Promise.resolve({}),-+ ),-+ );-+ const work = captureObservationFacts({ send: send as never }, 4);-+ const checked = expect(work).rejects.toThrow(-+ "DOMSnapshot.captureSnapshot timed out after 10000ms (tab 4)",-+ );-+ await vi.advanceTimersByTimeAsync(10_000);-+ await checked;-+ expect(send.mock.calls.map((call) => call[1])).toEqual([-+ "DOMSnapshot.enable",-+ "DOMSnapshot.captureSnapshot",-+ ]);-+ expect(vi.getTimerCount()).toBe(0);-+});-+it("bounds screenshots and ignores their late reply", async () => {-+ vi.useFakeTimers();-+ vi.spyOn(console, "warn").mockImplementation(() => {});-+ vi.spyOn(console, "debug").mockImplementation(() => {});-+ let finish!: (value: string) => void;-+ const work = runCdpCommand(-+ { tabId: 4 },-+ "Page.captureScreenshot",-+ () =>-+ new Promise<string>((resolve) => {-+ finish = resolve;-+ }),-+ );-+ const checked = expect(work).rejects.toBeInstanceOf(CdpReadTimeoutError);-+ await vi.advanceTimersByTimeAsync(3_000);-+ await checked;-+ finish("late image");-+ await Promise.resolve();-+ expect(vi.getTimerCount()).toBe(0);-+});-+-+it("distinguishes caller timeout from a late Chrome completion", async () => {-+ vi.useFakeTimers();-+ const warning = vi.spyOn(console, "warn").mockImplementation(() => {});-+ let finish!: (value: string) => void;-+ const work = runCdpCommand(-+ { tabId: 4 },-+ "Page.captureScreenshot",-+ () =>-+ new Promise<string>((resolve) => {-+ finish = resolve;-+ }),-+ );-+ const checked = expect(work).rejects.toBeInstanceOf(CdpReadTimeoutError);-+ await vi.advanceTimersByTimeAsync(3000);-+ await checked;-+ expect(warning.mock.calls.filter((c) => c[0] === "[bsk cdp] slow command settled")).toHaveLength(-+ 0,-+ );-+ await vi.advanceTimersByTimeAsync(5000);-+ finish("image");-+ await vi.advanceTimersByTimeAsync(0);-+ expect(warning).toHaveBeenCalledWith(-+ "[bsk cdp] slow command settled",-+ expect.objectContaining({ elapsedMs: 8000, outcome: "returned", late: true }),-+ );-+});-diff --git a/apps/extension/src/browser-driver/__tests__/task-focus.browser.test.ts b/apps/extension/src/browser-driver/__tests__/task-focus.browser.test.ts-new file mode 100644-index 0000000..fe79f2a---- /dev/null-+++ b/apps/extension/src/browser-driver/__tests__/task-focus.browser.test.ts-@@ -0,0 +1,96 @@-+// @vitest-environment node-+import { describe, expect, it } from "vitest";-+import { captureVomObservation } from "@/tools/observation";-+import { type CdpDebuggerApi, ChromiumCdp } from "../chromium-cdp";-+-+describe.skipIf(!process.env.BSK_GEOMETRY_CHROME)("real background task rendering", () => {-+ it.each([-+ 0, 2000,-+ ])("renders a background page with %i repeated controls and restores visibility on detach", async (controlCount) => {-+ // Raw CDP deliberately avoids Playwright, which enables focus emulation by default-+ // and would mask this exact regression even when a Chrome tab is inactive.-+ const { withChrome } = await import(-+ new URL(-+ "../../../../../evals/browser/cases/regression/snapshot-coordinates/chrome.mjs",-+ import.meta.url,-+ ).href-+ );-+ await withChrome(-+ { executable: process.env.BSK_GEOMETRY_CHROME, deviceScale: 1, zoom: 1 },-+ async (send: any) => {-+ const foreground = (await send("Target.getTargets")).targetInfos.find(-+ (t: any) => t.type === "page",-+ );-+ const { sessionId: foregroundSession } = await send("Target.attachToTarget", {-+ targetId: foreground.targetId,-+ flatten: true,-+ });-+ const url =-+ "data:text/html," +-+ encodeURIComponent(-+ '<title>Background task</title><p>Loading</p><script>requestAnimationFrame(()=>document.querySelector("p").textContent="Rendered")</script>' +-+ "<section><h2>Entry</h2><button>Open</button><p>Sample page content</p></section>".repeat(-+ controlCount,-+ ),-+ );-+ const { targetId } = await send("Target.createTarget", { url, background: true });-+ let sessionId = (await send("Target.attachToTarget", { targetId, flatten: true }))-+ .sessionId;-+ const evaluate = async (expression: string, session = sessionId) =>-+ (-+ await send(-+ "Runtime.evaluate",-+ { expression, awaitPromise: true, returnByValue: true },-+ session,-+ )-+ ).result.value;-+ // A newly created target may still expose the initial complete about:blank.-+ await expect.poll(() => evaluate("document.title")).toBe("Background task");-+ await expect.poll(() => evaluate("document.readyState")).toBe("complete");-+ expect(-+ await evaluate(-+ '({visibility:document.visibilityState,text:document.querySelector("p").textContent})',-+ ),-+ ).toEqual({ visibility: "hidden", text: "Loading" });-+ await send("Target.detachFromTarget", { sessionId });-+ const event = { addListener() {}, removeListener() {} };-+ const api = {-+ attach: async () => {-+ sessionId = (await send("Target.attachToTarget", { targetId, flatten: true }))-+ .sessionId;-+ },-+ detach: async () => {-+ await send("Target.detachFromTarget", { sessionId });-+ },-+ sendCommand: (_target: unknown, method: string, params: object) =>-+ send(method, params, sessionId),-+ onEvent: event,-+ onDetach: event,-+ } as unknown as CdpDebuggerApi;-+ const cdp = new ChromiumCdp(api);-+ try {-+ await cdp.acquireBackgroundExecution("task", 4);-+ expect(-+ await evaluate(-+ 'new Promise(resolve=>requestAnimationFrame(()=>resolve(document.querySelector("p").textContent)))',-+ ),-+ ).toBe("Rendered");-+ const observation = await captureVomObservation(cdp, 4, url);-+ expect(observation.text).toContain("Rendered");-+ expect(observation.refs).toHaveLength(controlCount);-+ const image = await cdp.send<{ data: string }>(4, "Page.captureScreenshot", {-+ format: "jpeg",-+ fromSurface: true,-+ });-+ expect(image.data.length).toBeGreaterThan(100);-+ expect(await evaluate("document.visibilityState", foregroundSession)).toBe("visible");-+ await cdp.releaseSessionTab("task", 4);-+ sessionId = (await send("Target.attachToTarget", { targetId, flatten: true })).sessionId;-+ expect(await evaluate("document.visibilityState")).toBe("hidden");-+ } finally {-+ cdp.dispose();-+ }-+ },-+ );-+ }, 20_000);-+});-diff --git a/apps/extension/src/browser-driver/chromium-cdp.ts b/apps/extension/src/browser-driver/chromium-cdp.ts-index 2779da7..eebb362 100644---- a/apps/extension/src/browser-driver/chromium-cdp.ts-+++ b/apps/extension/src/browser-driver/chromium-cdp.ts-@@ -32,6 +32,7 @@ import type {- NetworkResult,- } from "@/transport/types";- import { BackgroundExecution } from "./background-execution";-+import { runCdpCommand } from "./command-deadline";- import {- buildFrameGraph,- type CdpFrameGraph,-@@ -141,6 +142,7 @@ interface FrameDiscoveryState {- sessions: Set<string>;- pending: Set<Promise<void>>;- generation: number;-+ enabled: Map<string, Promise<void>>;- }-- async function settleBeforeDeadline(promises: Promise<void>[], deadline: number): Promise<boolean> {-@@ -165,13 +167,14 @@ async function settleBeforeDeadline(promises: Promise<void>[], deadline: number)- export class ChromiumCdp {- private readonly api: CdpDebuggerApi;- private readonly attachedTabs = new Set<number>();-+ private readonly pendingScreenshots = new Map<number, Promise<unknown>>();- private readonly attachmentIds = new Map<number, string>();- private readonly attachInFlight = new Map<number, Promise<void>>();- private readonly detachInFlight = new Map<number, Promise<void>>();- private readonly backgroundExecution = new BackgroundExecution(- (tabId) => this.attachmentIds.get(tabId),- (tabId, enabled) =>-- this.api.sendCommand({ tabId }, "Emulation.setFocusEmulationEnabled", { enabled }),-+ this.command({ tabId }, "Emulation.setFocusEmulationEnabled", { enabled }),- );- private readonly tabOwners = new Map<number, Set<string>>();- private readonly dialogBuffers = new Map<number, JavaScriptDialogInfo[]>();-@@ -295,7 +298,7 @@ export class ChromiumCdp {- async send<T = unknown>(tabId: number, method: string, params?: object): Promise<T> {- await this.ensureAttached(tabId);- try {-- const result = await this.api.sendCommand({ tabId }, method, params ?? {});-+ const result = await this.command({ tabId }, method, params ?? {});- return result as T;- } catch (err) {- throw normalizeError(err);-@@ -305,7 +308,7 @@ export class ChromiumCdp {- async sendToTarget<T = unknown>(target: CdpTarget, method: string, params?: object): Promise<T> {- await this.ensureAttached(target.tabId);- try {-- return (await this.api.sendCommand(target, method, params ?? {})) as T;-+ return (await this.command(target, method, params ?? {})) as T;- } catch (err) {- throw normalizeError(err);- }-@@ -563,6 +566,7 @@ export class ChromiumCdp {- this.networkDomainsEnabledTabs.clear();- this.networkRequestMeta.clear();- this.frameDiscovery.clear();-+ this.pendingScreenshots.clear();- await Promise.all(- tabs.map(async (tabId) => {- try {-@@ -574,8 +578,31 @@ export class ChromiumCdp {- );- }--+ hasPendingScreenshot(tabId: number): boolean {-+ return this.pendingScreenshots.has(tabId);-+ }-+-+ private command(target: CdpDebuggee, method: string, params: object): Promise<unknown> {-+ return runCdpCommand(target, method, () => {-+ const tabId = target.tabId;-+ if (method !== "Page.captureScreenshot" || tabId === undefined)-+ return this.api.sendCommand(target, method, params);-+ // A local deadline cannot cancel a Chrome command. Keep this fence until-+ // Chrome actually replies (or detaches), so polling cannot pile up captures.-+ if (this.pendingScreenshots.has(tabId))-+ throw new Error("Previous screenshot is still running in Chrome");-+ const pending = this.api.sendCommand(target, method, params);-+ this.pendingScreenshots.set(tabId, pending);-+ const clear = () => {-+ if (this.pendingScreenshots.get(tabId) === pending) this.pendingScreenshots.delete(tabId);-+ };-+ void pending.then(clear, clear);-+ return pending;-+ });-+ }-+- private async enablePageDomain(tabId: number): Promise<void> {-- await this.api.sendCommand({ tabId }, "Page.enable", {});-+ await this.command({ tabId }, "Page.enable", {});- }-- private async enableConsoleDomains(tabId: number): Promise<void> {-@@ -588,7 +615,7 @@ export class ChromiumCdp {- let failed = false;- for (const method of ["Runtime.enable", "Log.enable"]) {- try {-- await this.api.sendCommand({ tabId }, method, {});-+ await this.command({ tabId }, method, {});- } catch (err) {- failed = true;- console.debug("[bsk cdp] console domain enable failed", { tabId, method, err });-@@ -601,7 +628,7 @@ export class ChromiumCdp {-- private async enableNetworkDomain(tabId: number): Promise<void> {- if (this.networkDomainsEnabledTabs.has(tabId)) return;-- await this.api.sendCommand({ tabId }, "Network.enable", {});-+ await this.command({ tabId }, "Network.enable", {});- this.networkDomainsEnabledTabs.add(tabId);- }--@@ -613,13 +640,27 @@ export class ChromiumCdp {- }- }--- private async enableFrameDiscovery(target: CdpTarget): Promise<void> {-- await this.api.sendCommand(target, "Target.setAutoAttach", {-+ private enableFrameDiscovery(target: CdpTarget): Promise<void> {-+ const state = this.frameDiscoveryState(target.tabId);-+ const key = target.sessionId ?? "root";-+ const existing = state.enabled.get(key);-+ if (existing) return existing;-+ // Auto-attach remains enabled for this debugger session, including later-+ // navigation and new iframes. Reconfiguring it on every observation adds a-+ // browser round trip and needlessly repeats child-target discovery.-+ const work = this.command(target, "Target.setAutoAttach", {- autoAttach: true,- waitForDebuggerOnStart: false,- flatten: true,- filter: [{ type: "iframe", exclude: false }],-- });-+ })-+ .then(() => {})-+ .catch((error) => {-+ if (state.enabled.get(key) === work) state.enabled.delete(key);-+ throw error;-+ });-+ state.enabled.set(key, work);-+ return work;- }-- private bindFrameTargetHandler(): void {-@@ -646,6 +687,7 @@ export class ChromiumCdp {-- if (method === "Target.detachedFromTarget") {- const state = this.frameDiscovery.get(tabId);-+ state?.enabled.delete(sessionId);- if (state?.sessions.delete(sessionId)) state.generation += 1;- return;- }-@@ -712,6 +754,7 @@ export class ChromiumCdp {- sessions: new Set(),- pending: new Set(),- generation: 0,-+ enabled: new Map(),- };- this.frameDiscovery.set(tabId, created);- return created;-@@ -719,6 +762,7 @@ export class ChromiumCdp {-- private clearFrameState(tabId: number): void {- this.frameDiscovery.delete(tabId);-+ this.pendingScreenshots.delete(tabId);- }-- private bindDialogHandler(): void {-@@ -751,7 +795,7 @@ export class ChromiumCdp {- if (parsed.type === "prompt") {- handleParams.promptText = parsed.defaultPrompt ?? "";- }-- await this.api.sendCommand({ tabId }, "Page.handleJavaScriptDialog", handleParams);-+ await this.command({ tabId }, "Page.handleJavaScriptDialog", handleParams);- if (!this.attachedTabs.has(tabId) && !this.attachInFlight.has(tabId)) return;- const sequence = (this.dialogSequences.get(tabId) ?? 0) + 1;- this.dialogSequences.set(tabId, sequence);-diff --git a/apps/extension/src/browser-driver/command-deadline.ts b/apps/extension/src/browser-driver/command-deadline.ts-new file mode 100644-index 0000000..540d804---- /dev/null-+++ b/apps/extension/src/browser-driver/command-deadline.ts-@@ -0,0 +1,78 @@-+import type { CdpDebuggee } from "./chromium-cdp";-+-+// Bound renderer reads, not user-requested waits or mutations. An expired-+// CDP read cannot be cancelled individually; its late reply is ignored and-+// observation must stop rather than issue fallback reads against the same page.-+const READ_COMMANDS = new Set([-+ "Target.setAutoAttach",-+ "DOMSnapshot.enable",-+ "DOMSnapshot.captureSnapshot",-+ "Accessibility.enable",-+ "Accessibility.getFullAXTree",-+ "Page.getLayoutMetrics",-+ "Page.getFrameTree",-+ "DOM.getFrameOwner",-+ "Page.captureScreenshot",-+ "Emulation.setFocusEmulationEnabled",-+]);-+export class CdpReadTimeoutError extends Error {-+ constructor(method: string, tabId: number | undefined, timeout: number) {-+ super(-+ `Browser read ${method} timed out after ${timeout}ms (tab ${tabId}). Do not repeat the same read in a loop; report the timeout and let the browser task release control before retrying.`,-+ );-+ this.name = "CdpReadTimeoutError";-+ }-+}-+-+export async function runCdpCommand<T>(-+ target: CdpDebuggee,-+ method: string,-+ run: () => Promise<T>,-+): Promise<T> {-+ const started = Date.now();-+ const details = () => ({-+ tabId: target.tabId,-+ frameSessionId: target.sessionId,-+ method,-+ elapsedMs: Date.now() - started,-+ });-+ const slow = setTimeout(() => console.warn("[bsk cdp] slow command", details()), 2_000);-+ let deadline: ReturnType<typeof setTimeout> | undefined;-+ let timedOut = false;-+ const settled = (outcome: "returned" | "failed") => {-+ if (Date.now() - started >= 2_000)-+ console.warn("[bsk cdp] slow command settled", { ...details(), outcome, late: timedOut });-+ };-+ try {-+ const pending = run().then(-+ (value) => {-+ settled("returned");-+ return value;-+ },-+ (error) => {-+ settled("failed");-+ throw error;-+ },-+ );-+ if (!READ_COMMANDS.has(method)) return await pending;-+ const timeout = method === "Page.captureScreenshot" ? 3_000 : 10_000;-+ return await Promise.race([-+ pending,-+ new Promise<never>((_, reject) => {-+ deadline = setTimeout(() => {-+ timedOut = true;-+ reject(new CdpReadTimeoutError(method, target.tabId, timeout));-+ }, timeout);-+ }),-+ ]);-+ } catch (error) {-+ console.warn("[bsk cdp] command failed", {-+ ...details(),-+ error: error instanceof Error ? error.message : String(error),-+ });-+ throw error;-+ } finally {-+ clearTimeout(slow);-+ clearTimeout(deadline);-+ }-+}-diff --git a/apps/extension/src/tools/vom/capture-abort.ts b/apps/extension/src/tools/vom/capture-abort.ts-index 7ca65bf..429c373 100644---- a/apps/extension/src/tools/vom/capture-abort.ts-+++ b/apps/extension/src/tools/vom/capture-abort.ts-@@ -4,10 +4,12 @@ function captureAbortError(): Error {- return error;- }--+// Timed-out renderer reads are terminal too: AX/geometry fallback must not-+// keep issuing reads after the renderer has stopped answering.- export function isAbortError(error: unknown): boolean {- return (- typeof error === "object" &&- error !== null &&-- (error as { name?: string }).name === "AbortError"-+ ["AbortError", "CdpReadTimeoutError"].includes((error as { name?: string }).name ?? "")- );- }diff --git a/patches/browserskill/02-gateway-task-controls.patch b/patches/browserskill/02-gateway-task-controls.patchdeleted file mode 100644index b9c2b79a0..000000000--- a/patches/browserskill/02-gateway-task-controls.patch+++ /dev/null@@ -1,505 +0,0 @@-diff --git a/apps/extension/src/entrypoints/background.ts b/apps/extension/src/entrypoints/background.ts-index 830bbbe..cb88179 100644---- a/apps/extension/src/entrypoints/background.ts-+++ b/apps/extension/src/entrypoints/background.ts-@@ -4,6 +4,7 @@ import { getAuditEnabled } from "@/lib/audit";- import { attachAuditBridge } from "@/lib/audit-bridge";- import { ConnectionController } from "@/lib/connection-controller";- import { watchDaemonConnection } from "@/lib/daemon-connection-preference";-+import { attachGatewayUI } from "@/lib/gateway-ui";- import { startHeartbeat } from "@/lib/heartbeat";- import {- getConnectionEnabled,-@@ -27,6 +28,7 @@ import {- import { POPUP_PORT_NAME, type PopupInbound, type PopupOutbound } from "@/lib/popup-bridge";- import { recordFrameCoordinator } from "@/lib/recording/frame-coordinator";- import { attachSessionsLiveFlag } from "@/lib/sessions-live-flag";-+import { captureTaskPreview, taskTarget } from "@/lib/task-preview";- import { attachLongScreenshot } from "@/long-screenshot/background";- import { createDisconnectCleanup } from "@/session-manager/disconnect-cleanup";- import { attachSessionEventHandler } from "@/session-manager/event-handler";-@@ -63,7 +65,21 @@ export default defineBackground(() => {- url: __BSK_DAEMON_WS_URL__,- webSocketFactory: (url) => {- if (!connectionPreferenceValid) throw new Error("Connection settings are unavailable");-- return remoteSocket(url, remoteEndpoint);-+ const socket = remoteSocket(url, remoteEndpoint);-+ if (remoteEndpoint)-+ attachGatewayUI(socket, {-+ focus: async (sessionId) => {-+ const tabId = await taskTarget(sessions, sessionId);-+ const task = sessions.get(sessionId);-+ const tab = await chrome.tabs.get(tabId);-+ if (!task || !isAgentControlledTab(task, tabId)) throw new Error("Task unavailable");-+ await chrome.tabs.update(tabId, { active: true });-+ await chrome.windows.update(tab.windowId, { focused: true });-+ return { focused: true };-+ },-+ preview: (sessionId) => captureTaskPreview(sessions, cdp, sessionId),-+ });-+ return socket;- },- });- const sessions = new SessionManager({ remote: () => remoteEndpoint !== null });-diff --git a/apps/extension/src/lib/__tests__/gateway-ui.test.ts b/apps/extension/src/lib/__tests__/gateway-ui.test.ts-new file mode 100644-index 0000000..273c15b---- /dev/null-+++ b/apps/extension/src/lib/__tests__/gateway-ui.test.ts-@@ -0,0 +1,51 @@-+import { afterEach, describe, expect, it, vi } from "vitest";-+import { attachGatewayUI } from "../gateway-ui";-+-+afterEach(() => vi.unstubAllGlobals());-+function fixture() {-+ vi.stubGlobal("WebSocket", { OPEN: 1 });-+ const socket = Object.assign(new EventTarget(), { readyState: 1, send: vi.fn() });-+ const ui = {-+ focus: vi.fn(async () => ({ focused: true })),-+ preview: vi.fn(async () => ({ image_base64: "jpeg" })),-+ };-+ attachGatewayUI(socket as unknown as WebSocket, ui);-+ const native = vi.fn();-+ socket.addEventListener("message", native);-+ const request = async (body: unknown) => {-+ socket.dispatchEvent(new MessageEvent("message", { data: JSON.stringify(body) }));-+ await new Promise((resolve) => setTimeout(resolve, 0));-+ };-+ return { socket, ui, native, request };-+}-+describe("gateway UI side channel", () => {-+ it("routes UI requests independently and leaves native RPC untouched", async () => {-+ const f = fixture();-+ for (const name of ["preview", "focus"] as const) {-+ await f.request({ id: name, method: `gateway.task_${name}`, params: { session_id: "task" } });-+ expect(f.ui[name]).toHaveBeenCalledWith("task");-+ }-+ expect(f.native).not.toHaveBeenCalled();-+ await f.request({ id: "native", method: "tool.snapshot", params: {} });-+ expect(f.native).toHaveBeenCalledOnce();-+ });-+ it("rejects invalid session IDs without invoking browser work", async () => {-+ const f = fixture();-+ await f.request({ id: "bad", method: "gateway.task_focus", params: { session_id: 42 } });-+ expect(f.ui.focus).not.toHaveBeenCalled();-+ expect(JSON.parse(f.socket.send.mock.calls[0]![0])).toMatchObject({-+ error: { code: "invalid_params" },-+ });-+ });-+ it("reports failures and drops late replies on closed sockets", async () => {-+ const f = fixture();-+ f.ui.focus.mockRejectedValueOnce(new Error("unavailable"));-+ await f.request({ id: "focus", method: "gateway.task_focus", params: { session_id: "task" } });-+ expect(JSON.parse(f.socket.send.mock.calls[0]![0])).toMatchObject({-+ error: { code: "task_unavailable" },-+ });-+ f.socket.readyState = 3;-+ await f.request({ id: "late", method: "gateway.task_preview", params: { session_id: "task" } });-+ expect(f.socket.send).toHaveBeenCalledTimes(1);-+ });-+});-diff --git a/apps/extension/src/lib/__tests__/task-preview.test.ts b/apps/extension/src/lib/__tests__/task-preview.test.ts-new file mode 100644-index 0000000..3939bae---- /dev/null-+++ b/apps/extension/src/lib/__tests__/task-preview.test.ts-@@ -0,0 +1,180 @@-+import { afterEach, describe, expect, it, vi } from "vitest";-+import type { ChromiumCdp } from "@/browser-driver/chromium-cdp";-+import { runCdpCommand } from "@/browser-driver/command-deadline";-+import type { SessionManager } from "@/session-manager/manager";-+import { captureTaskPreview, withTaskPreviewStop } from "../task-preview";-+-+afterEach(() => {-+ vi.unstubAllGlobals();-+ vi.useRealTimers();-+ vi.restoreAllMocks();-+});-+function fixture() {-+ const task = {-+ remote: true,-+ agentWindowId: 10,-+ refStore: { documentRevision: () => 1 },-+ agentCreatedTabs: new Set([5]),-+ borrowedTabs: new Map(),-+ };-+ const manager = { get: () => task } as unknown as SessionManager;-+ const cdp = {-+ getAttachmentId: vi.fn(() => "attachment"),-+ hasPendingScreenshot: vi.fn(() => false),-+ acquireBackgroundExecution: vi.fn(async () => {}),-+ send: vi.fn(async (_tab, method) =>-+ method === "Page.getLayoutMetrics"-+ ? { cssVisualViewport: { pageX: 0, pageY: 0, clientWidth: 1280, clientHeight: 720 } }-+ : { data: btoa("jpeg") },-+ ),-+ } as unknown as ChromiumCdp;-+ const draw = vi.fn();-+ const close = vi.fn();-+ const sizes: number[] = [];-+ vi.stubGlobal("chrome", {-+ tabs: {-+ query: vi.fn(async () => [{ id: 5, windowId: 10, active: true }]),-+ get: vi.fn(async () => ({ id: 5, windowId: 10, title: "task" })),-+ sendMessage: vi.fn(async () => ({ ok: true })),-+ },-+ });-+ vi.stubGlobal(-+ "createImageBitmap",-+ vi.fn(async () => ({ width: 1280, height: 720, close })),-+ );-+ vi.stubGlobal(-+ "OffscreenCanvas",-+ class {-+ width: number;-+ height: number;-+ constructor(w: number, h: number) {-+ this.width = w;-+ this.height = h;-+ sizes.push(w, h);-+ }-+ getContext() {-+ return { drawImage: draw };-+ }-+ async convertToBlob() {-+ return new Blob(["thumbnail"]);-+ }-+ },-+ );-+ return { task, manager, cdp, sizes, close };-+}-+describe("independent task preview", () => {-+ it("keeps control and help overlays visible across repeated preview captures", async () => {-+ const f = fixture();-+ for (let i = 0; i < 3; i++) {-+ await expect(captureTaskPreview(f.manager, f.cdp, "visible")).resolves.toMatchObject({-+ tab_id: 5,-+ image_base64: btoa("thumbnail"),-+ });-+ }-+ expect(f.cdp.acquireBackgroundExecution).toHaveBeenCalledWith("visible", 5);-+ expect(f.cdp.send).toHaveBeenCalledTimes(3);-+ expect(chrome.tabs.sendMessage).not.toHaveBeenCalled();-+ });-+-+ it("lets native stop proceed after a stuck screenshot times out", async () => {-+ vi.useFakeTimers();-+ vi.spyOn(console, "warn").mockImplementation(() => {});-+ vi.spyOn(console, "debug").mockImplementation(() => {});-+ const f = fixture();-+ const original = vi.mocked(f.cdp.send).getMockImplementation()!;-+ vi.mocked(f.cdp.send).mockImplementation((tab, method, params) =>-+ method === "Page.captureScreenshot"-+ ? runCdpCommand({ tabId: tab }, method, () => new Promise<never>(() => {}))-+ : original(tab, method, params),-+ );-+ const stop = vi.fn(async () => {});-+ const frame = captureTaskPreview(f.manager, f.cdp, "stuck");-+ const checked = expect(frame).rejects.toThrow("Page.captureScreenshot timed out");-+ const released = withTaskPreviewStop(f.manager, "stuck", stop);-+ await expect(captureTaskPreview(f.manager, f.cdp, "stuck")).rejects.toThrow("stopping");-+ expect(stop).not.toHaveBeenCalled();-+ await vi.advanceTimersByTimeAsync(3_000);-+ await checked;-+ await released;-+ expect(stop).toHaveBeenCalledOnce();-+ expect(vi.getTimerCount()).toBe(0);-+ vi.mocked(f.cdp.send).mockImplementation(original);-+ await expect(-+ captureTaskPreview(f.manager, f.cdp, "stuck"),-+ ).resolves.toMatchObject({ tab_id: 5 });-+ });-+-+ it("blocks previews throughout native cleanup and restores them after a failed stop", async () => {-+ const f = fixture();-+ let reject!: (error: Error) => void;-+ const pending = new Promise<never>((_, fail) => { reject = fail; });-+ const stopping = withTaskPreviewStop(f.manager, "retry", () => pending);-+ const checked = expect(stopping).rejects.toThrow("return failed");-+ await expect(captureTaskPreview(f.manager, f.cdp, "retry")).rejects.toThrow("stopping");-+ expect(f.cdp.acquireBackgroundExecution).not.toHaveBeenCalled();-+ reject(new Error("return failed"));-+ await checked;-+ await expect(captureTaskPreview(f.manager, f.cdp, "retry")).resolves.toMatchObject({ tab_id: 5 });-+ });-+-+ it("coalesces captures and bounds the physical bitmap on HiDPI screens", async () => {-+ const f = fixture();-+ const first = captureTaskPreview(f.manager, f.cdp, "one");-+ expect(captureTaskPreview(f.manager, f.cdp, "one")).toBe(first);-+ const frame = await first;-+ expect(frame).toMatchObject({ tab_id: 5, format: "jpeg", image_base64: btoa("thumbnail") });-+ expect(f.sizes).toEqual([640, 360]);-+ expect(f.close).toHaveBeenCalled();-+ expect(f.cdp.send).toHaveBeenCalledExactlyOnceWith(5, "Page.captureScreenshot", {-+ format: "jpeg",-+ quality: 50,-+ fromSurface: true,-+ captureBeyondViewport: false,-+ });-+ });-+ it("skips polling before any browser work when Chrome still has a screenshot pending", async () => {-+ const f = fixture();-+ vi.mocked(f.cdp.hasPendingScreenshot).mockReturnValue(true);-+ await expect(captureTaskPreview(f.manager, f.cdp, "pending")).rejects.toThrow("still running");-+ expect(f.cdp.acquireBackgroundExecution).not.toHaveBeenCalled();-+ expect(f.cdp.send).not.toHaveBeenCalled();-+ });-+ it("does not capture an unowned active user tab", async () => {-+ const f = fixture();-+ f.task.agentCreatedTabs.clear();-+ await expect(captureTaskPreview(f.manager, f.cdp, "empty")).rejects.toThrow(-+ "Task tab unavailable",-+ );-+ expect(f.cdp.send).not.toHaveBeenCalled();-+ });-+ it("discards the result if authorization ends during capture", async () => {-+ const f = fixture();-+ vi.mocked(f.cdp.acquireBackgroundExecution).mockImplementation(async () => {-+ f.task.agentCreatedTabs.clear();-+ });-+ await expect(captureTaskPreview(f.manager, f.cdp, "ended")).rejects.toThrow(-+ "Task ended during capture",-+ );-+ });-+ it("uses an owned tab when an unauthorized user tab is active", async () => {-+ const f = fixture();-+ vi.mocked(chrome.tabs.query).mockResolvedValue([-+ { id: 9, windowId: 10, active: true },-+ { id: 5, windowId: 10, active: false },-+ ] as chrome.tabs.Tab[]);-+ await expect(captureTaskPreview(f.manager, f.cdp, "user-active")).resolves.toMatchObject({-+ tab_id: 5,-+ });-+ expect(f.cdp.send).toHaveBeenCalledWith(5, "Page.captureScreenshot", expect.anything());-+ });-+ it("discards a frame after the debugger attachment changes", async () => {-+ const f = fixture();-+ vi.mocked(f.cdp.send).mockImplementation(async () => {-+ vi.mocked(f.cdp.getAttachmentId).mockReturnValue("replacement");-+ return { data: btoa("jpeg") } as never;-+ });-+ await expect(captureTaskPreview(f.manager, f.cdp, "replaced")).rejects.toThrow(-+ "Task ended during capture",-+ );-+ });-+});-diff --git a/apps/extension/src/lib/gateway-ui.ts b/apps/extension/src/lib/gateway-ui.ts-new file mode 100644-index 0000000..ef0443f---- /dev/null-+++ b/apps/extension/src/lib/gateway-ui.ts-@@ -0,0 +1,40 @@-+interface GatewayUI {-+ focus(sessionId: string): Promise<unknown>;-+ preview(sessionId: string): Promise<unknown>;-+}-+-+/** WeKnora's optional UI protocol, attached only to authenticated remote sockets.-+ * Register before WSTransport so these requests bypass native automation. */-+export function attachGatewayUI(socket: WebSocket, ui: GatewayUI): void {-+ socket.addEventListener("message", (event) => {-+ let request: { id?: unknown; method?: unknown; params?: { session_id?: unknown } };-+ try {-+ request = JSON.parse(event.data);-+ if (!request || typeof request !== "object") return;-+ } catch {-+ return;-+ }-+ const methods: Record<string, (sessionId: string) => Promise<unknown>> = {-+ "gateway.task_focus": (id) => ui.focus(id),-+ "gateway.task_preview": (id) => ui.preview(id),-+ };-+ if (typeof request.method !== "string" || !Object.hasOwn(methods, request.method)) return;-+ event.stopImmediatePropagation();-+ if (typeof request.id !== "string" || !request.id) return;-+ const id = request.id;-+ const sessionId = request.params?.session_id;-+ const send = (body: object) => {-+ if (socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify({ id, ...body }));-+ };-+ if (typeof sessionId !== "string" || !sessionId) {-+ send({ error: { code: "invalid_params", message: "session_id is required" } });-+ return;-+ }-+ void Promise.resolve()-+ .then(() => methods[request.method as string]!(sessionId))-+ .then(-+ (result) => send({ result }),-+ () => send({ error: { code: "task_unavailable", message: "Browser task unavailable" } }),-+ );-+ });-+}-diff --git a/apps/extension/src/lib/task-preview.ts b/apps/extension/src/lib/task-preview.ts-new file mode 100644-index 0000000..a6d2532---- /dev/null-+++ b/apps/extension/src/lib/task-preview.ts-@@ -0,0 +1,143 @@-+import type { ChromiumCdp } from "@/browser-driver/chromium-cdp";-+import { isAgentControlledTab, type SessionManager } from "@/session-manager/manager";-+-+interface PreviewState {-+ pending?: Promise<unknown>;-+ stopping: number;-+}-+const previews = new WeakMap<object, PreviewState>();-+function previewState(task: object): PreviewState {-+ let state = previews.get(task);-+ if (!state) {-+ state = { stopping: 0 };-+ previews.set(task, state);-+ }-+ return state;-+}-+-+/** UI-only capture outside the automation queue, including human-help waits. */-+export function captureTaskPreview(-+ manager: SessionManager,-+ cdp: ChromiumCdp,-+ sessionId: string,-+): Promise<unknown> {-+ const task = manager.get(sessionId);-+ if (!task?.remote) return Promise.reject(new Error("Task unavailable"));-+ const state = previewState(task);-+ if (state.stopping) return Promise.reject(new Error("Task is stopping"));-+ if (state.pending) return state.pending;-+ const work = capture(manager, cdp, sessionId).finally(() => {-+ if (state.pending === work) state.pending = undefined;-+ });-+ state.pending = work;-+ return work;-+}-+-+/** Drain side-channel screenshots before the official stop handler detaches-+ * and closes tabs. No turn-end detach or custom session state is introduced. */-+export async function withTaskPreviewStop<T>(-+ manager: SessionManager,-+ sessionId: string | undefined,-+ stop: () => Promise<T>,-+): Promise<T> {-+ const task = sessionId ? manager.get(sessionId) : undefined;-+ if (!task?.remote) return stop();-+ const state = previewState(task);-+ state.stopping++;-+ try {-+ await state.pending?.catch(() => {});-+ return await stop();-+ } finally {-+ // A failed native stop can be retried; it must not permanently disable previews.-+ state.stopping--;-+ }-+}-+-+async function capture(manager: SessionManager, cdp: ChromiumCdp, sessionId: string) {-+ const task = manager.get(sessionId);-+ if (!task?.remote) throw new Error("Task unavailable");-+ const tabId = await taskTarget(manager, sessionId);-+ if (tabId === undefined || !isAgentControlledTab(task, tabId))-+ throw new Error("Task tab unavailable");-+ if (cdp.hasPendingScreenshot(tabId))-+ throw new Error("Previous screenshot is still running in Chrome");-+ const tab = await chrome.tabs.get(tabId);-+ // Preview bypasses the automation dispatcher, so acquire the same explicit-+ // control policy before reading a background page. Native session stop drains-+ // this capture before releasing the claim and closing tabs.-+ await cdp.acquireBackgroundExecution(sessionId, tabId);-+ if (manager.get(sessionId) !== task || !isAgentControlledTab(task, tabId))-+ throw new Error("Task ended during capture");-+ const attachment = cdp.getAttachmentId(tabId);-+ const revision = task.refStore.documentRevision(tabId);-+ // UI previews retain overlays: hiding them on every poll makes the user's-+ // control border and help prompts flicker. Agent screenshots hide them separately.-+ // Capture only the viewport and resize the bitmap below without a layout read.-+ const shot = await cdp.send<{ data: string }>(tabId, "Page.captureScreenshot", {-+ format: "jpeg",-+ quality: 50,-+ fromSurface: true,-+ captureBeyondViewport: false,-+ });-+ if (-+ manager.get(sessionId) !== task ||-+ !isAgentControlledTab(task, tabId) ||-+ cdp.getAttachmentId(tabId) !== attachment ||-+ task.refStore.documentRevision(tabId) !== revision-+ )-+ throw new Error("Task ended during capture");-+ // Viewport screenshots may use physical display pixels; HiDPI displays can-+ // return larger bitmaps. Bound the actual encoded image to the preview width.-+ let data = shot.data;-+ const bitmap = await createImageBitmap(-+ new Blob([Uint8Array.from(atob(data), (c) => c.charCodeAt(0))], { type: "image/jpeg" }),-+ );-+ try {-+ if (bitmap.width > 640) {-+ const canvas = new OffscreenCanvas(-+ 640,-+ Math.max(1, Math.round((bitmap.height * 640) / bitmap.width)),-+ );-+ const context = canvas.getContext("2d");-+ if (!context) throw new Error("Preview canvas unavailable");-+ context.drawImage(bitmap, 0, 0, canvas.width, canvas.height);-+ const jpeg = await canvas.convertToBlob({ type: "image/jpeg", quality: 0.5 });-+ data = btoa(-+ Array.from(new Uint8Array(await jpeg.arrayBuffer()), (b) => String.fromCharCode(b)).join(-+ "",-+ ),-+ );-+ }-+ } finally {-+ bitmap.close();-+ }-+ if (-+ manager.get(sessionId) !== task ||-+ !isAgentControlledTab(task, tabId) ||-+ cdp.getAttachmentId(tabId) !== attachment ||-+ task.refStore.documentRevision(tabId) !== revision-+ )-+ throw new Error("Task ended during capture");-+ return {-+ image_base64: data,-+ format: "jpeg",-+ tab_id: tabId,-+ title: tab.title ?? "",-+ captured_at: new Date().toISOString(),-+ };-+}-+-+/** Use the active owned tab, or another owned tab when the user has selected-+ * an unauthorized page. Window membership alone never grants access. */-+export async function taskTarget(manager: SessionManager, sessionId: string): Promise<number> {-+ const task = manager.get(sessionId);-+ if (!task?.remote) throw new Error("Task unavailable");-+ const tabs = await chrome.tabs.query({ windowId: task.agentWindowId });-+ if (manager.get(sessionId) !== task) throw new Error("Task unavailable");-+ const owned = tabs.filter(-+ (tab) => typeof tab.id === "number" && isAgentControlledTab(task, tab.id),-+ );-+ const tabId = (owned.find((tab) => tab.active) ?? owned[0])?.id;-+ if (tabId === undefined) throw new Error("Task tab unavailable");-+ return tabId;-+}-diff --git a/apps/extension/src/tools/session.ts b/apps/extension/src/tools/session.ts-index 4e0220b..ce13827 100644---- a/apps/extension/src/tools/session.ts-+++ b/apps/extension/src/tools/session.ts-@@ -1,3 +1,4 @@-+import { withTaskPreviewStop } from "@/lib/task-preview";- import {- DEFAULT_INTERACTION_PREFERENCES,- type InteractionPreferenceStore,-@@ -196,6 +197,14 @@ export async function handleSessionStop(- manager: SessionManager,- params: SessionStopParams,- deps: SessionStopDeps = {},-+): Promise<SessionStopResult | RpcError> {-+ return withTaskPreviewStop(manager, params?.session_id, () => stopSession(manager, params, deps));-+}-+-+async function stopSession(-+ manager: SessionManager,-+ params: SessionStopParams,-+ deps: SessionStopDeps,- ): Promise<SessionStopResult | RpcError> {- if (!params?.session_id) {- return {diff --git a/patches/browserskill/04-task-popup-ownership.patch b/patches/browserskill/04-task-popup-ownership.patchdeleted file mode 100644index 35d99f352..000000000--- a/patches/browserskill/04-task-popup-ownership.patch+++ /dev/null@@ -1,337 +0,0 @@-diff --git a/apps/extension/src/entrypoints/background.ts b/apps/extension/src/entrypoints/background.ts-index cb88179..cba98b8 100644---- a/apps/extension/src/entrypoints/background.ts-+++ b/apps/extension/src/entrypoints/background.ts-@@ -326,10 +326,12 @@ export default defineBackground(() => {- },- ...(ctx.signal !== undefined ? { signal: ctx.signal } : {}),- deps: {-- // Skip every Agent Window when choosing where to render the-- // overlay — Agent Windows boot on about:blank, which has no-- // content script, so they cannot surface an authorization decision.-- isAgentWindowId: (windowId) => sessions.findByWindowId(windowId) !== null,-+ // The requesting window may host consent for an in-place borrow.-+ // Candidate selection still excludes about:blank/restricted pages.-+ isAgentWindowId: (windowId) => {-+ const owner = sessions.findByWindowId(windowId);-+ return owner !== null && owner.sessionId !== ctx.sessionId;-+ },- // Resolve i18n strings per-borrow so language switches take effect- // without re-creating the dispatcher.- notificationCopy: makeBorrowNotificationCopy(),-diff --git a/apps/extension/src/session-manager/__tests__/task-popups.test.ts b/apps/extension/src/session-manager/__tests__/task-popups.test.ts-new file mode 100644-index 0000000..f859bdc---- /dev/null-+++ b/apps/extension/src/session-manager/__tests__/task-popups.test.ts-@@ -0,0 +1,79 @@-+import { afterEach, describe, expect, it, vi } from "vitest";-+import { SessionManager } from "../manager";-+import { withTaskPopups } from "../task-popups";-+-+afterEach(() => vi.unstubAllGlobals());-+async function fixture() {-+ let next = 10;-+ const manager = new SessionManager({-+ remote: () => true,-+ agentWindow: {-+ create: async () => next++,-+ remove: vi.fn(async () => {}),-+ ensureActiveTab: async (id) => id,-+ },-+ });-+ const task = await manager.start("one");-+ const other = await manager.start("two");-+ const tabs = new Map<number, { id: number; windowId: number; active?: boolean }>([-+ [10, { id: 10, windowId: 10, active: true }],-+ [11, { id: 11, windowId: 11, active: true }],-+ ]);-+ const listeners = new Set<(event: { sourceTabId: number; tabId: number }) => void>();-+ const move = vi.fn(async (id: number, props: { windowId: number }) =>-+ Object.assign(tabs.get(id)!, props),-+ );-+ vi.stubGlobal("chrome", {-+ tabs: { query: async () => [tabs.get(10)], get: async (id: number) => tabs.get(id), move },-+ webNavigation: {-+ onCreatedNavigationTarget: {-+ addListener: (fn: (event: { sourceTabId: number; tabId: number }) => void) =>-+ listeners.add(fn),-+ removeListener: (fn: (event: { sourceTabId: number; tabId: number }) => void) =>-+ listeners.delete(fn),-+ },-+ },-+ });-+ const create = (sourceTabId: number, tabId: number, windowId = 10) => {-+ tabs.set(tabId, { id: tabId, windowId });-+ for (const fn of listeners) fn({ sourceTabId, tabId });-+ };-+ return { manager, task, other, tabs, listeners, create, move };-+}-+describe("action-scoped popup ownership", () => {-+ it("claims noopener/nested targets and moves a popup window into its task", async () => {-+ const f = await fixture();-+ await withTaskPopups(f.manager, { session_id: "one" }, async () => {-+ f.create(10, 20);-+ f.create(20, 21, 200);-+ f.create(11, 22); // Another task's source.-+ f.tabs.set(23, { id: 23, windowId: 10 }); // User-created/moved tab, no navigation event.-+ });-+ expect(f.task.agentCreatedTabs).toEqual(new Set([10, 20, 21]));-+ expect(f.move).toHaveBeenCalledWith(21, { windowId: 10, index: -1 });-+ expect(f.listeners.size).toBe(0);-+ f.create(10, 24); // Outside an agent action.-+ expect(f.task.agentCreatedTabs.has(24)).toBe(false);-+ });-+ it("cannot take a tab from another task or use an unauthorized source", async () => {-+ const f = await fixture();-+ await withTaskPopups(f.manager, { session_id: "one", tab_id: 11 }, async () =>-+ f.create(11, 30),-+ );-+ await withTaskPopups(f.manager, { session_id: "one" }, async () => f.create(10, 11, 11));-+ expect(f.task.agentCreatedTabs).toEqual(new Set([10]));-+ expect(f.other.agentCreatedTabs).toEqual(new Set([11]));-+ });-+ it("cleans listeners on failure and rejects targets after source authorization ends", async () => {-+ const f = await fixture();-+ await expect(-+ withTaskPopups(f.manager, { session_id: "one" }, async () => {-+ f.task.agentCreatedTabs.delete(10);-+ f.create(10, 20);-+ throw new Error("input failed");-+ }),-+ ).rejects.toThrow("input failed");-+ expect(f.task.agentCreatedTabs.size).toBe(0);-+ expect(f.listeners.size).toBe(0);-+ });-+});-diff --git a/apps/extension/src/session-manager/task-popups.ts b/apps/extension/src/session-manager/task-popups.ts-new file mode 100644-index 0000000..53db1bf---- /dev/null-+++ b/apps/extension/src/session-manager/task-popups.ts-@@ -0,0 +1,72 @@-+import { isAgentControlledTab, type SessionManager } from "./manager";-+-+/** Attribute only Chrome-reported navigation targets created during an agent-+ * action on an owned source. Window membership and openerTabId are insufficient.-+ * Delayed/unattributed popups can still use the ordinary consent-based borrow. */-+export async function withTaskPopups<T>(-+ manager: SessionManager,-+ params: { session_id?: string; tab_id?: number },-+ run: () => Promise<T>,-+ onClaimed?: (tabId: number, windowId: number) => void,-+): Promise<T> {-+ const task = params.session_id ? manager.get(params.session_id) : null;-+ const events = globalThis.chrome?.webNavigation?.onCreatedNavigationTarget;-+ if (!task?.remote || !events) return run();-+ const source =-+ params.tab_id ??-+ (-+ await chrome.tabs.query({-+ windowId: task.agentWindowId,-+ active: true,-+ })-+ )[0]?.id;-+ if (source === undefined || !isAgentControlledTab(task, source)) return run();-+ const sources = new Set([source]);-+ const pending = new Set<Promise<void>>();-+ const live = () => manager.get(task.sessionId) === task && !manager.isWindowCloseExpected(task);-+ const created = ({ sourceTabId, tabId }: { sourceTabId: number; tabId: number }) => {-+ if (-+ !live() ||-+ !sources.has(sourceTabId) ||-+ !isAgentControlledTab(task, sourceTabId) ||-+ manager.list().some((other) => isAgentControlledTab(other, tabId))-+ )-+ return;-+ // Record ownership synchronously so a nested popup and cleanup see it.-+ task.agentCreatedTabs.add(tabId);-+ sources.add(tabId);-+ const work = (async () => {-+ try {-+ let tab = await chrome.tabs.get(tabId);-+ if (!live() || !isAgentControlledTab(task, tabId)) return;-+ const other = manager.findByWindowId(tab.windowId);-+ if (other && other !== task) {-+ task.agentCreatedTabs.delete(tabId);-+ sources.delete(tabId);-+ return;-+ }-+ if (tab.windowId !== task.agentWindowId) {-+ await chrome.tabs.move(tabId, { windowId: task.agentWindowId, index: -1 });-+ tab = await chrome.tabs.get(tabId);-+ }-+ if (!live() || !isAgentControlledTab(task, tabId)) return;-+ onClaimed?.(tabId, tab.windowId);-+ } catch (error) {-+ // Preserve a live tab's ownership if moving it failed, so stop can clean-+ // it up; Chrome's removal event forgets tabs that have already closed.-+ console.warn("[bsk] task popup setup failed", error);-+ }-+ })();-+ pending.add(work);-+ void work.then(() => pending.delete(work));-+ };-+ events.addListener(created);-+ try {-+ return await run();-+ } finally {-+ // Chrome can deliver this event just after the CDP input acknowledgement.-+ await new Promise((resolve) => setTimeout(resolve, 100));-+ events.removeListener(created);-+ await Promise.all(pending);-+ }-+}-diff --git a/apps/extension/src/tools/__tests__/tabs.test.ts b/apps/extension/src/tools/__tests__/tabs.test.ts-index 5a7239e..b48a15e 100644---- a/apps/extension/src/tools/__tests__/tabs.test.ts-+++ b/apps/extension/src/tools/__tests__/tabs.test.ts-@@ -298,7 +298,7 @@ describe("handleTabCreate", () => {- });-- describe("handleTabClose", () => {-- it("does not infer remote popup ownership from its opener and explains how to borrow it", async () => {-+ it("does not infer ownership from opener metadata but permits an approved in-place borrow", async () => {- const sm = new SessionManager({ agentWindow: fakeAgentWindow([100]), remote: () => true });- const ctx = await sm.start("aa11");- const state: FakeTabState = {-@@ -310,6 +310,15 @@ describe("handleTabClose", () => {- expect(- await handleTabClose(sm, { session_id: "aa11", tab_id: 5 }, { tabs: api }),- ).toMatchObject({ code: "permission_denied" });-+ expect(-+ await handleTabBorrow(-+ sm,-+ { session_id: "aa11", tab_id: 5 },-+ { tabs: api, approveBorrow: async () => false },-+ ),-+ ).toMatchObject({ code: "cancelled" });-+ expect(ctx.borrowedTabs.has(5)).toBe(false);-+ expect(ctx.agentCreatedTabs.has(5)).toBe(false);- const approval = vi.fn(async () => true);- expect(- await handleTabBorrow(-@@ -317,13 +326,32 @@ describe("handleTabClose", () => {- { session_id: "aa11", tab_id: 5 },- { tabs: api, approveBorrow: approval },- ),-- ).toMatchObject({-- code: "invalid_params",-- message: expect.stringContaining("regular browser window"),-- });-+ ).toMatchObject({ tab_id: 5, original_window_id: 100, agent_window_id: 100 });- expect(ctx.agentCreatedTabs.has(5)).toBe(false);-+ expect(ctx.borrowedTabs.has(5)).toBe(true);- expect(spies.remove).not.toHaveBeenCalled();-- expect(approval).not.toHaveBeenCalled();-+ expect(spies.move).not.toHaveBeenCalled();-+ expect(approval).toHaveBeenCalledOnce();-+ const windows = makeWindowsApi(state).api;-+ const release = vi.fn(async () => {});-+ expect(-+ await handleTabReturn(-+ sm,-+ { session_id: "aa11", tab_id: 5 },-+ {-+ tabs: api,-+ windows,-+ cdp: { releaseSessionTab: release },-+ agentOverlayReset: { resetAgentOverlays: vi.fn(async () => {}) },-+ },-+ ),-+ ).toMatchObject({ tab_id: 5, returned_to_window_id: 100 });-+ expect(release).toHaveBeenCalledWith("aa11", 5);-+ expect(ctx.borrowedTabs.has(5)).toBe(false);-+ expect(state.tabs.has(5)).toBe(true);-+ expect(-+ await handleTabSelect(sm, { session_id: "aa11", tab_id: 5 }, { tabs: api }),-+ ).toMatchObject({ code: "permission_denied" });- });- it("removes a tab inside the Agent Window", async () => {- const sm = new SessionManager({ agentWindow: fakeAgentWindow([100]) });-diff --git a/apps/extension/src/tools/dispatcher.ts b/apps/extension/src/tools/dispatcher.ts-index b713f2f..93908bc 100644---- a/apps/extension/src/tools/dispatcher.ts-+++ b/apps/extension/src/tools/dispatcher.ts-@@ -2,6 +2,7 @@ import type { InteractionPreferenceStore } from "@/lib/interaction-preferences";- import { OVERLAY_AUTOMATION_BYPASS } from "@/lib/overlay-bridge";- import { ScreenshotExports } from "@/long-screenshot/exports";- import type { SessionManager } from "@/session-manager/manager";-+import { withTaskPopups } from "@/session-manager/task-popups";- import type { Transport } from "@/transport/transport";- import type {- BlurParams,-@@ -276,7 +277,24 @@ export class ToolDispatcher {- } catch {- /* The daemon still has the original operation metadata. */- }-- const result = await this.invoke(req, ac.signal);-+ const createsPopup = [-+ "tool.click",-+ "tool.press_key",-+ "tool.evaluate",-+ "tool.navigate",-+ "tool.navigate_back",-+ "tool.navigate_forward",-+ "tool.fill",-+ "tool.select",-+ ].includes(req.method);-+ const result = createsPopup-+ ? await withTaskPopups(-+ this.sessions,-+ (req.params ?? {}) as { session_id?: string; tab_id?: number },-+ () => this.invoke(req, ac.signal),-+ this.onAgentTabClaimed,-+ )-+ : await this.invoke(req, ac.signal);- if (isRpcError(result)) {- body = { id: req.id, error: classifyCdpError(result) };- } else {-diff --git a/apps/extension/src/tools/tabs.ts b/apps/extension/src/tools/tabs.ts-index 4130ca4..86b5cfa 100644---- a/apps/extension/src/tools/tabs.ts-+++ b/apps/extension/src/tools/tabs.ts-@@ -697,13 +697,12 @@ async function validateBorrowTarget(- if (typeof tab.id !== "number" || typeof tab.windowId !== "number") {- return { code: "not_found", message: `tab ${tabId} not found` };- }-- if (tab.windowId === ctx.agentWindowId) {-+ // Remote unowned tabs can request normal approval in place. Merely moving-+ // a tab into this window never authorizes it; confirmation still runs below.-+ if (tab.windowId === ctx.agentWindowId && (!ctx.remote || isAgentControlledTab(ctx, tabId))) {- return {- code: "invalid_params",-- message:-- ctx.remote && !isAgentControlledTab(ctx, tabId)-- ? `tab_borrow: tab ${tabId} is not authorized and already lives in the Agent Window; move it to a regular browser window, then borrow it`-- : `tab_borrow: tab ${tabId} already lives in the Agent Window`,-+ message: `tab_borrow: tab ${tabId} already lives in the Agent Window`,- };- }- for (const s of manager.list()) {-@@ -823,14 +822,17 @@ async function executeBorrowCore(-- const originalWindowId = currentTab.windowId;- const originalIndex = typeof currentTab.index === "number" ? currentTab.index : 0;-- const moveErr = await moveTabForBorrow(-- p.tabsApi,-- p.tabId,-- p.ctx.agentWindowId,-- originalWindowId,-- originalIndex,-- p.signal,-- );-+ const moveErr =-+ originalWindowId === p.ctx.agentWindowId-+ ? null-+ : await moveTabForBorrow(-+ p.tabsApi,-+ p.tabId,-+ p.ctx.agentWindowId,-+ originalWindowId,-+ originalIndex,-+ p.signal,-+ );- if (moveErr) return moveErr;-- return { originalWindowId, originalIndex };diff --git a/patches/browserskill/05-last-tab-lifecycle.patch b/patches/browserskill/05-last-tab-lifecycle.patchdeleted file mode 100644index dcdfa5e46..000000000--- a/patches/browserskill/05-last-tab-lifecycle.patch+++ /dev/null@@ -1,174 +0,0 @@-diff --git a/apps/extension/src/tools/__tests__/tabs.test.ts b/apps/extension/src/tools/__tests__/tabs.test.ts-index ae9534d..71a0d56 100644---- a/apps/extension/src/tools/__tests__/tabs.test.ts-+++ b/apps/extension/src/tools/__tests__/tabs.test.ts-@@ -297,6 +297,99 @@ describe("handleTabCreate", () => {- });-- describe("handleTabClose", () => {-+ async function remoteCloseFixture() {-+ const sm = new SessionManager({ agentWindow: fakeAgentWindow([100]), remote: () => true });-+ const ctx = await sm.start("aa11");-+ ctx.agentCreatedTabs.clear();-+ ctx.agentCreatedTabs.add(5);-+ const state: FakeTabState = {-+ tabs: new Map([[5, { id: 5, windowId: 100 } as chrome.tabs.Tab]]),-+ nextTabId: 50,-+ windowsClosed: new Set(),-+ };-+ const { api, spies } = makeTabMutationApi(state);-+ const query = vi.fn(async (info: chrome.tabs.QueryInfo) =>-+ [...state.tabs.values()].filter((tab) => tab.windowId === info.windowId),-+ );-+ const claimed = vi.fn();-+ const deps = { tabs: api, tabsQuery: { query }, onAgentTabClaimed: claimed };-+ const close = (signal?: AbortSignal) =>-+ handleTabClose(sm, { session_id: "aa11", tab_id: 5 }, { ...deps, signal });-+ return { ctx, state, spies, query, claimed, close };-+ }-+-+ it("keeps the remote window alive when the agent closes its last tab", async () => {-+ const { ctx, state, spies, claimed, close } = await remoteCloseFixture();-+ spies.remove.mockImplementation(async (id: number) => {-+ state.tabs.delete(id);-+ if (state.tabs.size === 0) state.windowsClosed.add(100);-+ });-+ expect(await close()).toEqual({ tab_id: 5 });-+ expect(state.windowsClosed.size).toBe(0);-+ expect([...state.tabs.keys()]).toEqual([50]);-+ expect([...ctx.agentCreatedTabs]).toEqual([50]);-+ expect(spies.create).toHaveBeenCalledWith({ windowId: 100, url: "about:blank", active: false });-+ expect(claimed).toHaveBeenCalledWith(50, 100);-+ });-+-+ it("does not create a placeholder when another, even unowned, tab keeps the window open", async () => {-+ const { ctx, state, spies, close } = await remoteCloseFixture();-+ state.tabs.set(6, { id: 6, windowId: 100 } as chrome.tabs.Tab);-+ expect(await close()).toEqual({ tab_id: 5 });-+ expect(spies.create).not.toHaveBeenCalled();-+ expect([...state.tabs.keys()]).toEqual([6]);-+ expect(ctx.agentCreatedTabs.has(6)).toBe(false);-+ });-+-+ it("does not close the last tab if creating its replacement fails", async () => {-+ const { ctx, state, spies, close } = await remoteCloseFixture();-+ spies.create.mockRejectedValueOnce(new Error("cannot create"));-+ expect(await close()).toMatchObject({ code: "protocol_error", message: "cannot create" });-+ expect(spies.remove).not.toHaveBeenCalled();-+ expect([...state.tabs.keys()]).toEqual([5]);-+ expect([...ctx.agentCreatedTabs]).toEqual([5]);-+ });-+-+ it("honors a human interrupt while querying the remote window", async () => {-+ const { state, spies, query, close } = await remoteCloseFixture();-+ const controller = new AbortController();-+ query.mockImplementationOnce(async () => {-+ controller.abort();-+ return [...state.tabs.values()];-+ });-+ expect(await close(controller.signal)).toMatchObject({ code: "cancelled" });-+ expect(spies.create).not.toHaveBeenCalled();-+ expect(spies.remove).not.toHaveBeenCalled();-+ });-+-+ it("cleans the replacement and preserves the original on interruption during creation", async () => {-+ const { ctx, state, spies, claimed, close } = await remoteCloseFixture();-+ const controller = new AbortController();-+ spies.create.mockImplementationOnce(async () => {-+ const tab = { id: 50, windowId: 100 } as chrome.tabs.Tab;-+ state.tabs.set(50, tab);-+ controller.abort();-+ return tab;-+ });-+ expect(await close(controller.signal)).toMatchObject({ code: "cancelled" });-+ expect([...state.tabs.keys()]).toEqual([5]);-+ expect([...ctx.agentCreatedTabs]).toEqual([5]);-+ expect(claimed).not.toHaveBeenCalled();-+ expect(spies.remove).toHaveBeenCalledExactlyOnceWith(50);-+ });-+-+ it.each([-+ false,-+ true,-+ ])("handles failed close with failed placeholder cleanup=%s", async (cleanupFails) => {-+ const { ctx, state, spies, close } = await remoteCloseFixture();-+ spies.remove.mockRejectedValueOnce(new Error("cannot close"));-+ if (cleanupFails) spies.remove.mockRejectedValueOnce(new Error("cannot clean up"));-+ expect(await close()).toMatchObject({ code: "protocol_error", message: "cannot close" });-+ expect([...state.tabs.keys()]).toEqual(cleanupFails ? [5, 50] : [5]);-+ expect([...ctx.agentCreatedTabs]).toEqual(cleanupFails ? [5, 50] : [5]);-+ });-+- it("does not infer ownership from opener metadata but permits an approved in-place borrow", async () => {- const sm = new SessionManager({ agentWindow: fakeAgentWindow([100]), remote: () => true });- const ctx = await sm.start("aa11");-diff --git a/apps/extension/src/tools/dispatcher.ts b/apps/extension/src/tools/dispatcher.ts-index 8afdedf..3e167b1 100644---- a/apps/extension/src/tools/dispatcher.ts-+++ b/apps/extension/src/tools/dispatcher.ts-@@ -414,7 +414,11 @@ export class ToolDispatcher {- case "tool.tab_close":- return this.withHoverReleaseForRequest(- req.params as TabCloseParams,-- () => handleTabClose(this.sessions, req.params as TabCloseParams, { signal }),-+ () =>-+ handleTabClose(this.sessions, req.params as TabCloseParams, {-+ signal,-+ onAgentTabClaimed: this.onAgentTabClaimed,-+ }),- signal,- );- case "tool.tab_select":-diff --git a/apps/extension/src/tools/tabs.ts b/apps/extension/src/tools/tabs.ts-index 2570c74..43cfb12 100644---- a/apps/extension/src/tools/tabs.ts-+++ b/apps/extension/src/tools/tabs.ts-@@ -282,6 +282,8 @@ export async function handleTabList(-- export interface TabManagementDeps {- tabs?: TabMutationApi;-+ tabsQuery?: Pick<ChromeTabsApi, "query">;-+ onAgentTabClaimed?: (tabId: number, windowId: number) => void;- windows?: ChromeWindowsApi;- /** Abort hook (M10 will wire the full chain). */- signal?: AbortSignal;-@@ -540,12 +542,39 @@ export async function handleTabClose(- if (aborted(deps.signal, "tab_close")) {- return { code: "cancelled", message: "tab_close aborted" };- }-+ let placeholder: number | undefined;- try {-+ if (ctx.remote) {-+ const tabs = await (deps.tabsQuery ?? chromeTabsApi).query({ windowId: ctx.agentWindowId });-+ if (aborted(deps.signal, "tab_close"))-+ return { code: "cancelled", message: "tab_close aborted" };-+ if (tabs.length === 1 && tabs[0]?.id === params.tab_id) {-+ // Keep the session window alive until session.stop. Otherwise Chrome-+ // reports the agent's last-tab removal as a user-closed window, which-+ // pauses the next turn. This concrete tab is owned and cleaned normally.-+ const replacement = await createTabAndCleanup(ctx, deps, {-+ windowId: ctx.agentWindowId,-+ url: "about:blank",-+ active: false,-+ });-+ if (isRpcError(replacement)) return replacement;-+ placeholder = replacement.id;-+ deps.onAgentTabClaimed?.(placeholder, ctx.agentWindowId);-+ }-+ }- await getTabsApi(deps).remove(params.tab_id);- // Keep the tracking set accurate so session_stop won't try to close a- // tab that's already gone (design §3.1).- ctx.agentCreatedTabs.delete(params.tab_id);- } catch (err) {-+ if (placeholder !== undefined) {-+ try {-+ await getTabsApi(deps).remove(placeholder);-+ ctx.agentCreatedTabs.delete(placeholder);-+ } catch {-+ /* Retain the claim so session.stop can retry cleanup. */-+ }-+ }- return {- code: "protocol_error",- message: err instanceof Error ? err.message : String(err),diff --git a/patches/browserskill/06-navigation-response-deadline.patch b/patches/browserskill/06-navigation-response-deadline.patchdeleted file mode 100644index dba35b89c..000000000--- a/patches/browserskill/06-navigation-response-deadline.patch+++ /dev/null@@ -1,48 +0,0 @@-diff --git a/crates/bsk-cli/src/daemon/ipc.rs b/crates/bsk-cli/src/daemon/ipc.rs-index 69daf58..4695d48 100644---- a/crates/bsk-cli/src/daemon/ipc.rs-+++ b/crates/bsk-cli/src/daemon/ipc.rs-@@ -793,7 +793,14 @@ fn tool_dispatch_transport_timeout(method: &Method, params: &Value) -> Result<Du- timeout.map(|timeout| {- if matches!(- method,-- Method::ToolUpload | Method::ToolDownload | Method::ToolRequestHelp-+ Method::ToolUpload-+ | Method::ToolDownload-+ | Method::ToolRequestHelp-+ | Method::ToolNavigate-+ | Method::ToolNavigateBack-+ | Method::ToolNavigateForward-+ | Method::ToolReload-+ | Method::ToolWaitForNavigation- ) {- timeout.saturating_add(EXTENSION_RESPONSE_GRACE)- } else {-@@ -1820,12 +1827,27 @@ mod tests {- Method::ToolUpload,- Method::ToolDownload,- Method::ToolRequestHelp,-+ Method::ToolNavigate,-+ Method::ToolNavigateBack,-+ Method::ToolNavigateForward,-+ Method::ToolReload,-+ Method::ToolWaitForNavigation,- ] {- let dispatch_timeout = tool_dispatch_transport_timeout(&method, ¶ms).unwrap();- assert_eq!(dispatch_timeout, Duration::from_secs(62));- }- }--+ #[test]-+ fn default_navigation_deadline_allows_extension_timeout_response() {-+ for method in [Method::ToolNavigate, Method::ToolWaitForNavigation] {-+ assert_eq!(-+ tool_dispatch_transport_timeout(&method, &serde_json::json!({})).unwrap(),-+ DEFAULT_TOOL_TIMEOUT + EXTENSION_RESPONSE_GRACE-+ );-+ }-+ }-+- #[test]- fn extension_response_grace_does_not_change_other_tools() {- let params = serde_json::json!({diff --git a/patches/browserskill/README.md b/patches/browserskill/README.mddeleted file mode 100644index 625bc7674..000000000--- a/patches/browserskill/README.md+++ /dev/null@@ -1,119 +0,0 @@-# BrowserSkill downstream patches--The extension and daemon are based on official `main` commit-`fa953dc6fcd868827b93164e3bea26198e691224` (after `ext-v0.3.0`). Both still-report version `0.3.0`; the exact source baseline is recorded in-`scripts/browserskill-release.json`. The daemon is built with-`cargo build --locked --release -p bsk` and includes our navigation-response-deadline patch, so the official CLI 0.3.0 binary is not an equivalent replacement.-Native builds require Rust/Cargo and a C compiler (plus CMake on Linux).-Docker builds on the target architecture.--The patches include extension fixes and a daemon navigation-response deadline fix.-`scripts/build_browserskill.sh` applies the following patches in lexical order:--| Patch | Purpose | Removal condition |-| --- | --- | --- |-| `01-browser-read-reliability.patch` | Bound CDP reads, prevent overlapping timed-out screenshots, reuse frame discovery configuration | Equivalent upstream behavior passes the background rendering and timeout regressions |-| `02-gateway-task-controls.patch` | WeKnora preview and focus side channel; drain previews before native session stop | Upstream provides equivalent UI APIs and WeKnora migrates to them |-| `04-task-popup-ownership.patch` | Attribute navigation targets to the active agent action; allow consent-based in-place borrowing inside the task window | Upstream supports this popup lifecycle without weakening per-tab authorization |-| `05-last-tab-lifecycle.patch` | Keep a temporary owned blank tab when an agent closes the last remote task tab; normal session stop removes it | Upstream distinguishes agent last-tab cleanup from user window closure |-| `06-navigation-response-deadline.patch` | Allow navigation lifecycle timeout results to arrive before the daemon transport deadline | Upstream adds equivalent navigation response grace |--Background execution and viewport/full-page screenshot support use upstream-PRs #249, #250 and #253. VOM sibling-context caching is upstream PR #271, so-patch 03 was removed. Redirect document tracking and cancelled-navigation-reconciliation also use upstream code (including PR #280); patch 06 now changes-only the daemon deadline. The numbering gaps preserve existing patch identities.--The preview side channel explicitly acquires upstream background execution-because it bypasses the automation dispatcher. Native session stop drains-in-flight previews before the official handler releases control and closes tabs.-Retained tasks keep the official session and debugger; turn completion only-stops preview polling in WeKnora. Do not restore the old-`shouldKeepTaskActive` callback or a second focus-emulation cache.--Remote authentication, credential storage/migration, renewal, connection settings,-and dedicated Agent Windows use upstream code. Patch 04 extends the-upstream borrow/return flow while preserving explicit consent and per-tab isolation.-Do not restore the old `remote-extension-connection.patch`: upstream PR #227-already incorporates its remote connection support with different ownership and-window semantics.--## Companion UI contract--Only authenticated remote sockets handle these extra request frames. They do not-enter the native daemon's automation queue:--```json-{"id":"wk-ui-unique","method":"gateway.task_preview","params":{"session_id":"server-owned-session"}}-```--- `gateway.task_preview`: returns `image_base64`, `format: "jpeg"`, `tab_id`,- `title`, and `captured_at`. The encoded image is at most 640 pixels wide.- Captures are coalesced and restricted to a concrete owned tab. Authorization,- document revision and debugger identity are checked before returning a frame.- UI previews include the extension's control and help overlays so periodic- captures do not hide and restore them in the user's browser. Agent screenshots- still suppress overlays to preserve unobstructed page content.-- `gateway.task_focus`: explicitly activates an existing owned tab and its window;- returns `{ "focused": true }`. It never creates a session.--Errors use the native-shaped `{ "id": "…", "error": { "code": "…", "message": "…" } }`-envelope. These two methods are downstream APIs, not official BrowserSkill RPCs.-The official unmodified extension returns `unknown_method` for these UI requests.-Turn cleanup needs no custom RPC: retained tasks keep their session, and completed-tasks use native session stop. Keep serving the companion ZIP for preview/focus.--## Intentional behavior changes--- Remote tasks use official dedicated Agent Windows. The old background-tab-group- preference is no longer used; no `tabGroups` permission is added.-- Only Chrome navigation-target events from an owned source during an agent action- grant popup ownership (including `rel=noopener`). A bounded 100 ms event tail- follows the input acknowledgement. Window membership/opener metadata alone do- not authorize tabs; delayed or unattributed targets use the borrow flow.-- Unowned tabs already inside the task window can be borrowed with normal browser- approval. They remain borrowed user tabs, are returned without being closed,- and lose access immediately on return. Other task windows remain isolated.-- Closing the last owned tab through `tab_close` keeps a temporary owned blank tab- until session stop, preventing Chrome window removal from being misreported as- a human interruption. Actual user window closure still pauses the task.-- Human help and borrowing follow the upstream focus/confirmation behavior.-- Remote upload/download remain unsupported, as defined upstream.--Even though the version remains 0.3.0, users must install the rebuilt ZIP.-Upgrade users by replacing the existing unpacked extension directory and reloading-it after ending active tasks. Keeping the extension ID allows upstream migration-from legacy Chrome storage into extension-origin IndexedDB. Installing under a new-ID requires pairing again. Old saved tab groups are not removed automatically.--## Validation--Apply patches to a clean pinned checkout, install frozen dependencies and run:--```sh-pnpm --filter @browser-skill/extension exec wxt prepare-pnpm --filter @browser-skill/extension compile-pnpm --filter @browser-skill/extension test-pnpm --filter @browser-skill/vom test-pnpm ext:build:zip-BSK_GEOMETRY_CHROME=/path/to/test-chrome BSK_BACKGROUND_CHROME=/path/to/test-chrome \- pnpm --filter @browser-skill/extension exec vitest run --maxWorkers=1 \- src/browser-driver/__tests__/task-focus.browser.test.ts \- src/tools/__tests__/background-execution.browser.test.ts \- src/tools/__tests__/background-screenshot.browser.test.ts \- src/tools/__tests__/background-full-page.browser.test.ts-cargo test --locked -p bsk daemon::ipc::tests-```--Run WeKnora's `TestRealExtension` with the built extension, pinned daemon and an-isolated Chromium profile; environment variables are documented in-`website-docs/05-clients/09-local-browser.md`. It exercises actual pairing, screenshot and-input RPC, agent popup selection/read/close and in-place borrow approval/revocation, independent preview during help waits,-focus, pause/resume, retained-session continuity and completed-task cleanup.-It separately verifies that agent last-tab closure permits the next turn and-manual window closure blocks automation until explicit resume.--Upstream references: [PR #227](https://github.com/Tencent/BrowserSkill/pull/227),-[remote connection contract](https://github.com/Tencent/BrowserSkill/blob/fa953dc6fcd868827b93164e3bea26198e691224/docs/remote-extension-connection.md).diff --git a/scripts/browserskill-release.json b/scripts/browserskill-release.jsonindex 7283b2da8..7f3786b5d 100644--- a/scripts/browserskill-release.json+++ b/scripts/browserskill-release.json@@ -2,10 +2,10 @@"version": "0.3.0","extension": {"version": "0.3.0",- "source_commit": "fa953dc6fcd868827b93164e3bea26198e691224"+ "source_commit": "3da449e9ff2a1f25adc7170fb41d5ed7a82d84d5"},"daemon": {- "source_commit": "fa953dc6fcd868827b93164e3bea26198e691224",+ "source_commit": "3da449e9ff2a1f25adc7170fb41d5ed7a82d84d5","build": "cargo build --locked --release -p bsk"}}diff --git a/scripts/browserskill.md b/scripts/browserskill.mdnew file mode 100644index 000000000..79a15c340--- /dev/null+++ b/scripts/browserskill.md@@ -0,0 +1,141 @@+# BrowserSkill upstream integration++The extension and daemon are based on official `main` commit+`3da449e9ff2a1f25adc7170fb41d5ed7a82d84d5` (after `ext-v0.3.0`, including the+merged upstream PRs #291, #296, #297 and #318). Both still report version `0.3.0`;+the exact source baseline is recorded in `scripts/browserskill-release.json`.+The daemon is built with `cargo build --locked --release -p bsk` from the same+commit. The published CLI 0.3.0 binary and the published 0.3.0 extension ZIP+predate this baseline and are not equivalent replacements. Native builds+require Rust/Cargo and a C compiler (plus CMake on Linux). Docker builds on the+target architecture.++`scripts/build_browserskill.sh` builds the unmodified upstream checkout. No+BrowserSkill patches are applied or maintained downstream.++Renderer read reliability is provided by upstream PR #318: snapshot/AX captures+have a 20 s deadline, other bounded reads use 10 s, and a pending timed-out read+blocks further guarded reads until it settles or its debugger session detaches.+Navigation alone does not clear the gate. Errors retain+`data.reason = renderer_read_timeout`; unavailable child frames can be omitted+without discarding healthy frame content.++## Retired patches++| Former patch | Replacement |+| --- | --- |+| `01-browser-read-reliability.patch` | Upstream PR #318: bounded renderer reads, per-session read gates, capture fallback termination and debugger frame discovery. |+| `02-gateway-task-controls.patch` | Upstream PR #296: the optional UI channel `ui.task_preview` / `ui.task_focus` (renamed from `gateway.*`). WeKnora calls the official methods. |+| `03-vom-render-performance.patch` | Upstream PR #271 |+| `04-task-popup-ownership.patch` | Upstream PR #297: popups opened by native click/key input inside the Agent Window become observed, controllable tabs that session stop preserves. |+| `05-last-tab-lifecycle.patch` | Host side. `Manager.Call` runs `tool.tab_list` with `scope: "agent"` before `tool.tab_close`; when the target is the only tab in the Agent Window it first creates an agent-owned `about:blank` tab through `tool.tab_create`. Only official RPCs are involved. |+| `06-navigation-response-deadline.patch` | Upstream PR #291 (daemon navigation response grace). |++Background execution and viewport/full-page screenshot support use upstream+PRs #249, #250 and #253. Redirect document tracking and cancelled-navigation+reconciliation use upstream code including PR #280. Remote authentication,+credential storage/migration, renewal, connection settings and dedicated Agent+Windows use upstream PR #227. Do not restore the old+`remote-extension-connection.patch`, `shouldKeepTaskActive` callback or a second+focus-emulation cache.++Retained tasks keep the official session and debugger; turn completion only+stops preview polling in WeKnora. Completed tasks use native session stop.++## UI channel++The preview and focus side channel is now the official optional UI channel+documented in the upstream+[remote connection contract](https://github.com/Tencent/BrowserSkill/blob/3da449e9ff2a1f25adc7170fb41d5ed7a82d84d5/docs/remote-extension-connection.md#optional-ui-channel).+Only authenticated remote sockets handle these request frames; they bypass the+native automation queue and never start a session:++```json+{"id":"wk-ui-unique","method":"ui.task_preview","params":{"session_id":"server-owned-session"}}+```++- `ui.task_preview`: returns `image_base64`, `format: "jpeg"`, `tab_id`,+ `title` and `captured_at`; the frame is at most 640 pixels wide, captures are+ coalesced per task and a poll that arrives while Chrome still holds one is+ refused with `timeout` / `preview_busy`. Overlays stay visible in previews.+- `ui.task_focus`: activates the task's owned tab and raises its window,+ returning `{ "focused": true }`.++Errors use the native envelope with typed codes (`not_found`, `timeout`,+`cancelled`, `cdp_failed`) and an optional `data.reason`. WeKnora maps every+error except `unknown_method` to a transient preview failure. Extensions built+before PR #296, including the published 0.3.0 ZIP, answer `unknown_method`;+WeKnora then disables preview polling and reports the extension as outdated.++## Intentional behavior changes versus the published 0.3.0 extension++- Remote tasks use official dedicated Agent Windows. No `tabGroups` permission.+- Popup attribution follows upstream PR #297: only a main-frame navigation+ target from a controlled source during native click/key input, within the+ same Agent Window, becomes an observed tab. Observed tabs are readable and+ closable but never enter the agent-created set; session stop preserves them and their window. Independent+ popup windows, late or unattributed targets use `tab_borrow` and `tab_return`.+ An unowned tab that already sits in the Agent Window must be moved to a regular window before it+ can be borrowed.+- Closing the last tab of the Agent Window through `tab_close` keeps an+ agent-owned blank tab until session stop (host-side, see above), so Chrome's+ window removal is not misreported as a human interruption. If the close is+ refused or interrupted while the target still exists, the blank tab is removed+ again. Actual user window closure still pauses the task.+- Borrow confirmation follows the browser's preference and uses an HTTP(S) page+ in a regular user window. The integration fixture supplies such a page; neither+ extension settings nor a popup window can host the prompt. Borrowed tabs cannot+ be closed through `tab_close`. Return them with `tab_return`; if the original+ window disappeared, upstream may create a normal fallback window with a new-tab+ placeholder. These returned user pages are preserved when the task ends.+- Human help follows the upstream focus/confirmation behavior.+- Remote upload/download remain unsupported, as defined upstream.++Even though the version remains 0.3.0, users must install the rebuilt ZIP.+Upgrade users by replacing the existing unpacked extension directory and+reloading it after ending active tasks. Keeping the extension ID preserves the+migrated credentials; installing under a new ID requires pairing again.++## Validation++Use a clean pinned upstream checkout, install frozen dependencies and run:++```sh+pnpm --filter @browser-skill/extension exec wxt prepare+pnpm --filter @browser-skill/extension compile+pnpm --filter @browser-skill/extension test+pnpm --filter @browser-skill/vom test+pnpm ext:build:zip+BSK_GEOMETRY_CHROME=/path/to/test-chrome BSK_BACKGROUND_CHROME=/path/to/test-chrome \+ pnpm --filter @browser-skill/extension exec vitest run --maxWorkers=1 \+ src/tools/__tests__/background-execution.browser.test.ts \+ src/tools/__tests__/background-screenshot.browser.test.ts \+ src/tools/__tests__/background-full-page.browser.test.ts+cargo test --locked -p bsk daemon::ipc::tests+```++Run WeKnora's `TestRealExtension` with the built extension, pinned daemon and an+isolated Chromium profile. It exercises actual pairing, screenshot and input RPC,+same-window target selection/read/close, independent popup borrow/read/return and+access revocation, the in-window borrow rejection followed by borrow+approval/revocation of a tab moved to a regular window,+independent preview during help waits, focus, pause/resume, retained-session+continuity and completed-task cleanup. It separately verifies that agent+last-tab closure permits the next turn and manual window closure blocks+automation until explicit resume. Cleanup checks preserve the exact initial and+returned user tab IDs, permitting only the new-tab placeholder recorded from an+official fallback return; arbitrary extra tabs still fail the test.++```sh+BROWSERSKILL_TEST_EXTENSION=/path/to/unpacked/chrome-mv3 \+BROWSERSKILL_TEST_BINARY=/path/to/bsk \+BROWSERSKILL_TEST_CHROMIUM=/path/to/test-chromium \+BROWSERSKILL_TEST_PLAYWRIGHT=/path/to/playwright-core/index.mjs \+ go test ./internal/browserskill -run '^TestRealExtension$' -count=1 -v+```++Upstream references: [PR #227](https://github.com/Tencent/BrowserSkill/pull/227),+[PR #291](https://github.com/Tencent/BrowserSkill/pull/291),+[PR #296](https://github.com/Tencent/BrowserSkill/pull/296),+[PR #297](https://github.com/Tencent/BrowserSkill/pull/297),+[PR #318](https://github.com/Tencent/BrowserSkill/pull/318).diff --git a/scripts/build_browserskill.sh b/scripts/build_browserskill.shindex 037110bb1..dbff85527 100755--- a/scripts/build_browserskill.sh+++ b/scripts/build_browserskill.sh@@ -34,10 +34,6 @@ trap 'rm -rf "$build_dir"' EXITgit clone --no-checkout https://github.com/Tencent/BrowserSkill.git "$build_dir/source"git -C "$build_dir/source" checkout --detach "$source_commit"-for patch in "$repo_root"/patches/browserskill/*.patch; do- git -C "$build_dir/source" apply --check "$patch"- git -C "$build_dir/source" apply "$patch"-done(cd "$build_dir/source"npx --yes [email protected] install --frozen-lockfile@@ -46,8 +42,8 @@ donecp "$build_dir/source/apps/extension/dist/browser-skillextension-${extension_version}-chrome.zip" "$output_dir/browser-skill-weknora-${extension_version}.zip"cp "$build_dir/source/LICENSE" "$output_dir/BrowserSkill-LICENSE"-# Build the daemon from the same source and apply our navigation-response-# deadline fix; published CLI binaries do not include this downstream patch.+# Build the daemon from the same pinned source; the published CLI 0.3.0 binary+# predates the navigation-response grace fix (upstream PR #291).cargo_target_dir="${CARGO_TARGET_DIR:-$build_dir/target}"mkdir -p "$cargo_target_dir"cargo_target_dir="$(cd "$cargo_target_dir" && pwd)"diff --git a/scripts/test_browserskill_extension.mjs b/scripts/test_browserskill_extension.mjsindex 693e86f12..4e5deda5a 100644--- a/scripts/test_browserskill_extension.mjs+++ b/scripts/test_browserskill_extension.mjs@@ -6,7 +6,7 @@ import { pathToFileURL } from 'node:url';const lines = createInterface({ input: process.stdin });const first = await new Promise(resolve => lines.once('line', resolve));-const { pairing, extension, chromium: executablePath, playwright } = JSON.parse(first);+const { pairing, extension, chromium: executablePath, playwright, fixture } = JSON.parse(first);const { chromium } = await import(pathToFileURL(playwright).href);const profile = await mkdtemp('/tmp/wkb-chrome-');let browser;@@ -34,12 +34,19 @@ try {await popup.locator('form button[type="submit"]').click();await popup.waitForFunction(() => document.querySelector('#remote-pairing')?.value === '' || document.querySelector('form [role=alert]'));if (await popup.locator('form [role=alert]').count()) throw new Error('Extension authorization failed before browser tests');+ // Official borrow confirmation needs an injectable page in a normal user+ // window. Extension settings and an isolated popup cannot host that prompt.+ const confirmationPage = await browser.newPage();+ await confirmationPage.goto(fixture);+ await confirmationPage.locator('browser-skill-overlay').waitFor({state:'attached'});const initial = await worker.evaluate(async () => {const window = await chrome.windows.getLastFocused();const tabs = await chrome.tabs.query({windowId:window.id,active:true});return {windowId:window.id,tabId:tabs[0].id,tabIds:(await chrome.tabs.query({})).map(t=>t.id)};});const originalWindow = { windowId: initial.windowId, tabId: initial.tabId };+ const preservedTabs = new Set();+ let beforeReturn;process.stdout.write('ready\n');for await (const command of lines) {if (command === 'close') break;@@ -86,7 +93,7 @@ try {await chrome.debugger.sendCommand({tabId:tab.id}, 'Runtime.evaluate', {expression:'0', returnByValue:true});used.push(tab.id);} catch (error) {- if (!/not attached|No tab|No target/i.test(String(error))) throw error;+ if (!/not attached|No tab|No target|Cannot access a chrome:\/\/ URL/i.test(String(error))) throw error;}}return used;@@ -95,7 +102,37 @@ try {}if (command === 'check-cleanup') {const state = await worker.evaluate(async () => ({ids:(await chrome.tabs.query({})).map(t=>t.id)}));- process.stdout.write(JSON.stringify({cleaned:state.ids.length===initial.tabIds.length && state.ids.every(id=>initial.tabIds.includes(id))})+'\n');+ const expected = new Set([...initial.tabIds, ...preservedTabs]);+ const missing = [...expected].filter(id => !state.ids.includes(id));+ const unexpected = state.ids.filter(id => !expected.has(id));+ const cleaned = missing.length === 0 && unexpected.length === 0;+ process.stdout.write(JSON.stringify(cleaned ? {cleaned} : {cleaned, missing, unexpected})+'\n');+ }+ if (command.startsWith('before-tab-return ')) {+ const id = Number(command.split(' ')[1]);+ beforeReturn = await worker.evaluate(async (tabId) => ({+ tabId, tabs: await chrome.tabs.query({}), windows: await chrome.windows.getAll({}),+ }), id);+ process.stdout.write('return-recorded\n');+ }+ if (command.startsWith('expect-returned-tab ')) {+ // Admit only the returned page and the official fallback window's new-tab+ // placeholder. Never allow arbitrary extra tabs to hide task cleanup leaks.+ const returned = JSON.parse(command.slice('expect-returned-tab '.length));+ if (!beforeReturn || beforeReturn.tabId !== returned.tab_id) throw new Error('Missing return snapshot');+ const tabs = await worker.evaluate(async () => chrome.tabs.query({}));+ const target = tabs.find(tab => tab.id === returned.tab_id);+ if (!target || target.windowId !== returned.returned_to_window_id) throw new Error('Returned tab missing or misplaced');+ const added = tabs.filter(tab => !beforeReturn.tabs.some(previous => previous.id === tab.id));+ const newWindow = !beforeReturn.windows.some(window => window.id === target.windowId);+ if (added.length > 1 || added.some(tab => !returned.fallback || !newWindow ||+ tab.windowId !== target.windowId || (tab.pendingUrl ?? tab.url) !== 'chrome://newtab/')) {+ throw new Error('Unexpected tabs created during tab_return');+ }+ preservedTabs.add(target.id);+ for (const tab of added) preservedTabs.add(tab.id);+ beforeReturn = undefined;+ process.stdout.write('returned-tab-preserved\n');}if (command === 'remember-foreground') {const foreground = await worker.evaluate(async () => {@@ -114,7 +151,7 @@ try {// Extension API creation simulates a user-created tab: no navigation// source event, even though it is inside the Agent Window.return chrome.tabs.create({windowId:source.windowId,url:source.url+'?user-tab=1',active:true});- }, initial.tabIds);+ }, [...initial.tabIds, ...preservedTabs]);const page = await createdPage;await page.waitForURL('**/*?user-tab=1');await page.locator('browser-skill-overlay').waitFor({state:'attached'});@@ -128,9 +165,19 @@ try {}, id);process.stdout.write('fixture-window-closed\n');}+ if (command.startsWith('move-fixture-tab-out ')) {+ // Upstream refuses to borrow an unowned tab that already lives in the+ // Agent Window; the user must move it to a regular window first.+ const id = Number(command.split(' ')[1]);+ await worker.evaluate(async ({tabId, windowId}) => {+ await chrome.tabs.move(tabId, {windowId, index:-1});+ }, {tabId:id, windowId:originalWindow.windowId});+ process.stdout.write('fixture-tab-moved\n');+ }if (command.startsWith('remove-fixture-tab ')) {const id = Number(command.split(' ')[1]);await worker.evaluate(async (tabId) => chrome.tabs.remove(tabId), id);+ preservedTabs.delete(id);process.stdout.write('fixture-tab-removed\n');}if (command === 'check-background') {diff --git a/website-docs/05-clients/09-local-browser.md b/website-docs/05-clients/09-local-browser.mdindex e3e0644d2..78dad1101 100644--- a/website-docs/05-clients/09-local-browser.md+++ b/website-docs/05-clients/09-local-browser.md@@ -15,7 +15,9 @@ WeKnora 通过 BrowserSkill daemon 和配套 Chrome 扩展,将用户电脑上### 人工参与与任务恢复-任务可操作自己创建的标签;用户原有标签需要明确借用授权,手动拖入任务窗口也不等于授权。结束任务时关闭任务新建页面、归还借用页面。+任务可操作自己创建的标签;任务窗口内由点击或按键打开、且通过来源校验的新标签也可操作,结束任务时会保留。独立弹出窗口和用户原有标签通过 `tab_borrow` 借用,按浏览器设置确认授权后操作,完成后用 `tab_return` 归还。结束任务时关闭任务显式创建的页面、归还借用页面。++手动拖入任务窗口不等于授权;未授权页面已在任务窗口内时,需要用户先移到普通窗口再借用。借用确认提示需要普通窗口中的 HTTP(S) 页面承载,扩展设置页、新标签页和独立弹窗不能承载。若借用后原窗口消失,归还可能创建普通备用窗口;归还页面不会随任务结束被关闭。登录、验证码或授权步骤由 `request_help` 发起。按预览提示进入浏览器,完成后在浏览器帮助提示中确认;Agent 再观察页面并继续。仅在聊天中说“请登录”不会创建人工接管提示。帮助等待最多五分钟,超时或取消会保留现场并暂停。@@ -33,7 +35,7 @@ WeKnora 通过 BrowserSkill daemon 和配套 Chrome 扩展,将用户电脑上./scripts/build_browserskill.sh```-需要 Git、Node.js、Python 3、Rust/Cargo 和 C 编译器,Linux 还需要 CMake。固定源码版本由 `scripts/browserskill-release.json` 管理,补丁位于 `patches/browserskill/`,产物输出到 `artifacts/browserskill/`。使用对应操作系统与架构的 daemon,并按实际安装路径配置:+需要 Git、Node.js、Python 3、Rust/Cargo 和 C 编译器,Linux 还需要 CMake。固定源码版本由 `scripts/browserskill-release.json` 管理,直接构建上游源码,不应用额外补丁,产物输出到 `artifacts/browserskill/`。使用对应操作系统与架构的 daemon,并按实际安装路径配置:```dotenvBROWSERSKILL_BINARY=/opt/weknora/browserskill/bsk@@ -49,7 +51,7 @@ BROWSERSKILL_PUBLIC_URL=wss://weknora.example.com/api/v1/local-browser/extension本机可用 localhost WS,远端要求浏览器信任的 WSS 证书。内网可以使用受信任的企业 CA。显式设置 `BROWSERSKILL_BINARY=` 可关闭能力;修改 Docker 环境变量后使用 `docker compose up -d app frontend` 重建容器。-配套扩展和 daemon 必须一同升级,不能只按显示的 0.3.0 版本号判断兼容性;上游同版本原版不包含所有配套接口。覆盖原解压目录并重新加载可保留扩展 ID,重新安装导致 ID 改变时需要重新配对。分发时保留 `BrowserSkill-LICENSE`。+配套扩展和 daemon 必须一同升级,不能只按显示的 0.3.0 版本号判断兼容性;上游早期发布的 0.3.0 二进制和 ZIP 早于当前固定提交,不包含所需修复和 UI 接口。覆盖原解压目录并重新加载可保留扩展 ID,重新安装导致 ID 改变时需要重新配对。分发时保留 `BrowserSkill-LICENSE`。## 多副本与入口代理