@tea-agent/loop-agent 0.43.0-next.10 → 0.43.0-next.12

package/CHANGELOG.md

@@ -2,18 +2,36 @@
 
 ## [Unreleased]
 
+- 修复前端 Plan 无法提交实现步骤的问题：finalize_plan 支持按 AC 绑定实施动作，缺漏在节点内返回修正，避免空计划反复进入设计审查。
+
+- 修复前端最终审查反复猜错范围 ID：明确 checkpoint 参数和补交步骤，收尾正确识别 checkpoint 之后的审批结论。
+
+- 前端实现流程简化为需求实现覆盖审查和 `npm run build`，不再强制单测或测试方案；行为测试可后补，构建结果不冒充行为验证。
+
 ### 改进
 
+- Operator Chat 内置内部 provider 瞬态异常恢复：即使目标仓库未执行 `loop-agent init`，也能识别完整或被裁剪的 `UnknownError` / `TypeValidationError` / `LLMRequestError` / 502 / 中文「网络波动、模型处理超时」响应，将其规范化后交给 Pi 原生有界重试；Console 缺省使用 loop-agent 推荐重试参数，项目显式字段优先于用户全局字段，用户配置优先于推荐默认值。共享纯分类器同时生成 OpenCode 插件谓词，overflow、认证、权限、配额、取消和业务错误继续 fail-fast。
+
+- Operator Chat 浏览器面板默认以完整权限运行（去掉 iframe 沙箱与「临时解锁」状态条），并放开本机回环地址限制——`localhost` / `127.0.0.1` / `::1` 等本地开发服务器可直接在面板内浏览；地址栏仍仅放行 http/https，`javascript:` / `data:` / `file:` 等危险协议继续拦截，拒绝嵌入站点（X-Frame-Options / frame-ancestors）的解释面板与出口保持不变。
+
 - 前端 Plan 普通分片按本批完整需求材料打包，固定提示词、用户消息和工具定义不再挤占 24 KB 分片目标，也不再触发发送前的机械二分，减少小需求逐 AC 会话；实际模型容量检查与超限恢复继续生效。
 
 - 前端 Plan 小任务合并规划不再受固定 48 KB 输入门槛限制，避免提示词、用户消息或工具定义变长导致额外分片；完整输入、其余任务规模条件及容量恢复机制保持不变。
 - 节点侧栏修复执行分次下拉菜单被执行记录工具栏遮挡的问题，直接展示所选失败尝试的简要原因，并移除重复的左右切换箭头。
 - Operator Chat 的 Pi Runtime 按职责拆出工具构造、运行态检视和 SDK 适配，并共用创建/恢复/分叉的会话准备流程；对外入口、错误类型和会话行为保持不变。
 
+### 修复
+
+- 修复 Operator Chat 的跨会话输入污染与快速重复提交：切换会话时立即撤销旧会话发送权，草稿、附件和 ↑ 输入历史按会话独立保存；发送、排队、撤回、编辑、插话、文件建议和图片读取的迟到结果只回写原会话。提交改用带快照的有界 attempt，相同内容的快速双 Enter/双击只产生一次请求，失败恢复或排队响应不再覆盖后来输入；流式更新和会话切换保持同一个 composer DOM，中文 IME 更稳定。同步修复 durable 用户消息确认后时间重排导致闪烁光标跑到用户消息上方的问题。
+
+- 前端设计审查的写入门禁只统计已提交的审批终态，避免审查范围、发现记录导致合法审批被误判为缺失或歧义；要求修改时保留具体审查意见，缺失、重复及冲突终态仍阻断写入。
+
 ## [0.42.1] - 2026-09-09
 
 ### 新增
 
+- Console Chat 的 `/goal` 持续目标能力对 Pi 模式开放（与工作流模式同语义）：斜杠面板两模式均可见 `/goal`；Pi 会话注册 `get_goal` / `create_goal` / `update_goal` 工具并纳入激活集；Goal HTTP 接口（创建/暂停/恢复/清除）在 Pi 会话不再返回模式拒绝；GoalBar 与目标编辑面板在 Pi 会话渲染；压缩恢复、每轮 Goal 上下文与有界自主续跑（仅显式 `/goal` 才 arm，maxRounds 上限，reload/重启/出错/暂停即 disarm）在 Pi 会话可用。
+
 - Operator Chat 浏览器面板（DSH 风格）：Console 右侧辅助栏新增「浏览器」tab——地址栏（自动补 https、仅 http/https、禁止 javascript/data/file 等危险协议与本机回环地址）、后退/前进/刷新导航栈、系统浏览器跳转；页面运行在无 same-origin、无 top-navigation 的沙箱 iframe 中（访问的页面拿不到 Console 的存储与 API），沙箱状态条支持单页面临时解锁（红色警示 + 一键恢复）；对拒绝被嵌入的站点（X-Frame-Options / frame-ancestors）给出明确解释面板与「在系统浏览器打开 / 仍要加载」出口，探测端点仅返回响应头、仅限 http(s) 非回环、8 秒硬超时。
 - Operator Chat 源代码管理（DSH 风格）：模型获得 `scm` 工具（status/diff/stage/unstage/discard/commit/log/branch/push/pull，固定参数 git 无 shell、限时限量输出）；Console 右侧辅助栏新增「源码」面板（DSH GitView 布局——分支下拉切换、已暂存/更改分组与全部暂存/取消暂存、单行提交框 Ctrl+Enter、内联分页历史带 refs 徽标与相对时间、点击文件看 diff、右键菜单放弃更改/复制路径）；模型与面板共用同一工作区级 ScmService。
 - Operator Chat 在具备 Aimax 凭据资格时，向对话进程注入 `$AIMAX_AUTH_TOKEN`（明文或 `sm4:v1:` 解密后的 ticket），供 skills 读取；文件缺失、无法解析或解密失败时不注入该变量。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.43.0-next.10",
-  "gitSha": "a57ccda19e1372045d03071a01e7e6df1be2e942",
-  "builtAt": "2026-09-10T04:37:15.842Z"
+  "version": "0.43.0-next.12",
+  "gitSha": "59f2e162841fbf8171ebaa6963c6cec95eb98512",
+  "builtAt": "2026-09-10T14:30:24.298Z"
 }

package/dist/commands/client-recovery.js

@@ -18,6 +18,7 @@ export const BACKOFF_MS = [2000, 4000, 8000, 16000, 30000];
 export const MAX_SESSION_RETRIES = 5;
 /** Hard cap for OpenCode overflow compact+resume recoveries (≤ 2). */
 export const MAX_OVERFLOW_RECOVERIES = 1;
+import { buildGeneratedTransientProviderClassifierSource, classifyTransientProviderError, } from "../shared/pi-provider-recovery.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
 import { CONTEXT_OVERFLOW_PHRASES, buildGeneratedOverflowClassifierSource, isContextOverflow as classifySharedOverflow, } from "../shared/pi-context-pressure/overflow.js";
 export { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY };
@@ -51,17 +52,6 @@ const PERMANENT_MESSAGE_PATTERNS = [
         pattern: /\b(business validation|invalid task|schema validation)\b/i,
     },
 ];
-const TRANSIENT_MESSAGE_PATTERNS = [
-    /\bcode[:\s]*502\b/i,
-    /\b502\b/,
-    /\bLLMRequestError\b/i,
-    /\bnetwork fluctuation\b/i,
-    /\btimeout\b/i,
-    /\btransient provider failure\b/i,
-    /\bnon-standard (payload|response)\b/i,
-    /\bupstream returned\b/i,
-    /\bmodel processing timeout\b/i,
-];
 export function isClientRecoveryMode(value) {
     return (typeof value === "string" &&
         CLIENT_RECOVERY_MODES.includes(value));
@@ -172,30 +162,16 @@ export function isContextOverflow(error) {
     return classifySharedOverflow(error);
 }
 function looksTransient(error) {
-    const text = collectErrorText(error);
-    if (TRANSIENT_MESSAGE_PATTERNS.some((pattern) => pattern.test(text)))
-        return true;
-    if (error && typeof error === "object") {
-        const record = error;
-        if (record.code === 502 || record.status === 502)
-            return true;
-        if (record.data && typeof record.data === "object") {
-            const data = record.data;
-            if (data.code === 502 || data.status === 502)
-                return true;
-        }
-    }
-    return false;
+    return classifyTransientProviderError(error).retryable;
 }
 /**
  * Decide whether an OpenCode error should be resumed by the project plugin.
- * Only compensates transient UnknownError paths that built-in APIError retry misses.
+ * Compensates wrapped UnknownError / TypeValidation failures and known stripped
+ * internal-provider fluctuation messages that built-in APIError retry misses.
  *
- * TypeValidation bypass: a bare TypeValidationError (provider/SDK surfaces
- * zod invalid_union directly, without the UnknownError wrapper) is treated as
- * a retryable transient-unknown-error ONLY when it also carries a transient
- * signal (502 / LLMRequestError / timeout / etc.). A pure schema mismatch
- * without a transient signal is still rejected (resumable: false).
+ * The historical success reason remains `transient-unknown-error` for report
+ * compatibility. A pure schema mismatch without a transient signal is still
+ * rejected (resumable: false).
  */
 export function classifyTransientUnknownError(error) {
     const permanent = permanentReason(error);
@@ -208,6 +184,9 @@ export function classifyTransientUnknownError(error) {
     }
     const isUnknownShape = hasUnknownErrorShape(error);
     const isTypeValidationShape = hasTypeValidationShape(error);
+    if (looksTransient(error)) {
+        return { resumable: true, reason: "transient-unknown-error" };
+    }
     if (!isUnknownShape && !isTypeValidationShape) {
         return {
             resumable: false,
@@ -215,14 +194,11 @@ export function classifyTransientUnknownError(error) {
             interaction: PERMANENT_ERROR_INTERACTION,
         };
     }
-    if (!looksTransient(error)) {
-        return {
-            resumable: false,
-            reason: "unknown-non-transient",
-            interaction: PERMANENT_ERROR_INTERACTION,
-        };
-    }
-    return { resumable: true, reason: "transient-unknown-error" };
+    return {
+        resumable: false,
+        reason: "unknown-non-transient",
+        interaction: PERMANENT_ERROR_INTERACTION,
+    };
 }
 export function nextBackoffMs(attempt) {
     if (!Number.isInteger(attempt) ||
@@ -478,8 +454,9 @@ export function buildOpenCodeTransientRetryPluginSource() {
  * loop-agent OpenCode transient recovery plugin
  * Path: ${OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH}
  *
- * Compensates transient UnknownError cases that OpenCode built-in APIError
- * retry does not cover. Never runs concurrently with session.status === "retry".
+ * Compensates wrapped UnknownError / TypeValidation failures and known
+ * stripped internal-provider fluctuation messages that OpenCode built-in
+ * APIError retry does not cover. Never runs concurrently with session.status === "retry".
  * Permanent failures use interaction "${PERMANENT_ERROR_INTERACTION}".
  * User aborts (MessageAbortedError / cancel words) are silently cleared.
  * Best-effort file log: ${OPENCODE_TRANSIENT_RETRY_LOG_PATH}.
@@ -502,7 +479,7 @@ const LOG_PATH = (() => {
 const PERMANENT_INTERACTION = ${JSON.stringify(PERMANENT_ERROR_INTERACTION)};
 const BACKOFF_MS = ${JSON.stringify([...BACKOFF_MS])};
 const MAX_RETRIES = ${MAX_SESSION_RETRIES};
-${buildGeneratedContextOverflowPatternSource()}
+${buildGeneratedTransientProviderClassifierSource()}
 void logToFile("load ok");
 
 const sessionState = new Map();
@@ -563,19 +540,7 @@ function isPermanent(error) {
 
 function isTransientUnknown(error) {
   if (isPermanent(error)) return false;
-  const text = textOf(error);
-  const hasUnknown = /UnknownError/i.test(text) || (error && /UnknownError/i.test(String(error.name || "")));
-  const hasTypeValidation =
-    /\\bTypeValidationError\\b/i.test(text) ||
-    /Type validation failed/i.test(text) ||
-    (error && /TypeValidationError/i.test(String(error.name || "")));
-  if (!hasUnknown && !hasTypeValidation) return false;
-  return (
-    /\\b(code[:\\s]*502|502|LLMRequestError|network fluctuation|timeout|transient provider failure|non-standard)\\b/i.test(
-      text,
-    ) ||
-    (error && (error.code === 502 || error.status === 502))
-  );
+  return isKnownTransientProviderError(error);
 }
 
 function buildResumePrompt(sessionId, error, attempt) {

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

@@ -2286,9 +2286,13 @@ export async function createFrontendPlanLedgerTools(input) {
     const finalizePlanTool = defineTool({
         name: "finalize_plan",
         label: "finalize_plan",
-        description: "Commit the finalize_plan terminal. Requirements, verification targets, and evidence gaps (optional) were already committed incrementally through record_plan_requirement / record_plan_verification_target / record_plan_evidence_gap; finalize_plan assembles them from the ledger together with these optional remaining fields, publishes the canonical editable patch on a target-surface fact, and commits the terminal. A successful terminal commit occurs exactly once. If validation fails, correct only the reported facts and retry finalize.",
-        promptSnippet: "Commit the finalize_plan terminal (ledger fields + optional residualRisks / realIntegrationGap).",
+        description: "Commit the finalize_plan terminal. Requirements, verification targets, and evidence gaps (optional) were already committed incrementally through record_plan_requirement / record_plan_verification_target / record_plan_evidence_gap; finalize_plan requires implementationSteps: [{requirementIds, action}] covering every frozen requirement (shared steps allowed), and assembles them with the ledger and optional remaining fields, publishes the canonical editable patch on a target-surface fact, and commits the terminal. A successful terminal commit occurs exactly once. If validation fails, correct only the reported facts and retry finalize.",
+        promptSnippet: "Commit finalize_plan with implementationSteps: [{requirementIds, action}] covering every frozen requirement; optional residualRisks / realIntegrationGap.",
         parameters: Type.Object({
+            implementationSteps: Type.Optional(Type.Array(Type.Object({
+                requirementIds: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+                action: Type.String({ minLength: 1 }),
+            }, { additionalProperties: false }))),
             residualRisks: optionalStringArray,
             realIntegrationGap: optionalString,
         }, { additionalProperties: false }),
@@ -2305,8 +2309,23 @@ export async function createFrontendPlanLedgerTools(input) {
                 if (missingData.length)
                     return planToolReceipt({ ok: false, kind: "finalize_plan", code: "PLAN_DATA_FLOW_INCOMPLETE", error: missingData.map(f => f.reason).join("; ") });
                 const fragment = assemblePlanPatchFromCommittedFacts(committed, contractInheritance) ?? {};
+                const requiredIds = new Set([
+                    ...(input.requirementIds ?? []),
+                    ...contractInheritance.keys(),
+                    ...(Array.isArray(fragment.requirements) ? fragment.requirements.flatMap((entry) => isRecordObject(entry) && typeof entry.id === "string" ? [entry.id] : []) : []),
+                ]);
+                const steps = params?.implementationSteps ?? [];
+                const coveredIds = new Set(steps.flatMap(step => step.requirementIds));
+                const missingRequirementIds = [...requiredIds].filter(id => !coveredIds.has(id));
+                const unknownRequirementIds = [...coveredIds].filter(id => !requiredIds.has(id));
+                if (missingRequirementIds.length || unknownRequirementIds.length || steps.some(step => !step.action.trim())) {
+                    return planToolReceipt({ ok: false, kind: "finalize_plan", code: "PLAN_IMPLEMENTATION_STEPS_INCOMPLETE",
+                        error: `Submit finalize_plan with non-empty implementationSteps: [{requirementIds: [exact frozen IDs], action: "what to change and where"}]. Cover every requirement; shared steps may cover several IDs. Missing: ${missingRequirementIds.join(", ") || "none"}; unknown: ${unknownRequirementIds.join(", ") || "none"}. Actions must not be blank. Do not add a test plan.`,
+                    });
+                }
                 const patch = {
                     ...fragment,
+                    ...(steps.length ? { implementationSteps: steps.map(step => `[${[...new Set(step.requirementIds)].join(", ")}] ${step.action.trim()}`) } : {}),
                     ...(params?.residualRisks
                         ? { residualRisks: params.residualRisks }
                         : {}),
@@ -3802,7 +3821,7 @@ const FRONTEND_PLAN_SEGMENTS = [
         toolNames: null,
         instruction: [
             "PLAN PHASE — finalize.",
-            "All record_* tools are available only for a narrowly named correction if the finalize receipt reports missing or invalid facts. Otherwise call finalize_plan exactly once with no extra fields.",
+            "All record_* tools are available only for a narrowly named correction if the finalize receipt reports missing or invalid facts. Otherwise call finalize_plan with implementationSteps: [{requirementIds, action}] covering every frozen requirement. Describe concrete changes within approved paths, including what constraints preserve; shared steps may cover related IDs. Do not add tests or a test plan.",
         ].join(" "),
     },
 ];
@@ -4318,12 +4337,14 @@ export async function runFrontendReviewSegmentedSessions(input) {
             index--;
             continue;
         }
+        const completionInstruction = `${item.repairs ? "REPAIR: the prior session did not commit all required checkpoints/verdict. Do not repeat the review narrative. " : ""}Complete these exact runtime scope IDs using complete_review_scope: ${JSON.stringify(scopes.map(scope => scope.id))}. These are scope IDs, not node IDs. ${finalScope ? `After those checkpoints succeed, call exactly one terminal tool: ${terminalKinds.join(" or ")}. A prose conclusion is not a committed verdict.` : "More scopes remain; do not submit an overall verdict yet."}`;
+        const userMessage = `${input.sessionOptions.userMessage}\n\n${completionInstruction}`;
         if (++calls > 128)
             return { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: "FRONTEND_REVIEW_RECOVERY_EXHAUSTED: session quota reached" };
-        last = await observeFrontendSession({ ...input.observation, phase: `${input.phase}/scope`, scopeIds: scopes.map(s => s.id), prompt, userMessage: input.sessionOptions.userMessage, customTools,
+        last = await observeFrontendSession({ ...input.observation, phase: `${input.phase}/scope`, scopeIds: scopes.map(s => s.id), prompt, userMessage, customTools,
             artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-${calls}.json` : undefined,
             committedCount: () => protocol.committedFacts().length, durableCommittedCount: () => protocol.committedFacts().length,
-        }, observer => input.piStepFn({ ...input.sessionOptions, prompt, onAttemptObservation: observer, writerToolPolicy: { requireSdk: true, customTools } }));
+        }, observer => input.piStepFn({ ...input.sessionOptions, prompt, userMessage, onAttemptObservation: observer, writerToolPolicy: { requireSdk: true, customTools } }));
         await input.tools.flush();
         await input.inventory.validate();
         if (last.timedOut || /interrupt|termination-unconfirmed|budget_breach/.test(last.failureCategory))
@@ -4607,7 +4628,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
     const buildPhasePrompt = (segment, missing = [], scopeIds = allRequirementIds) => {
         const compact = allRequirementIds.length > 0
             ? compactFrontendPlanPromptForRequirementSlice(input.basePrompt, scopeIds, {
-                includeRequirementText: segment.id === "global-mock-data",
+                includeRequirementText: segment.id === "global-mock-data" || segment.id === "finalize",
                 includeVerificationTargets: false,
                 includeDesignEvidence: segment.id === "global-dependency-deviation" || segment.id === "finalize",
                 includeChecklist: false,

package/dist/executors/shell-executor.js

@@ -2329,7 +2329,7 @@ async function collectReviewTerminalKinds(runDir, reviewNodeId) {
             const kind = record.fact.kind;
             return typeof kind === "string" ? kind : "";
         })
-            .filter(Boolean);
+            .filter((kind) => kind === "approve_review" || kind === "request_review_changes");
     }
     catch {
         return [];
@@ -2348,7 +2348,7 @@ async function collectDesignTerminalKinds(runDir, designNodeId) {
             const kind = record.fact.kind;
             return typeof kind === "string" ? kind : "";
         })
-            .filter(Boolean);
+            .filter((kind) => kind === "approve_design" || kind === "request_design_changes");
     }
     catch {
         return [];
@@ -2974,6 +2974,7 @@ async function executeFrontendCloseout(input, meta) {
         const contract = frontendImplementationContractSchema.parse(JSON.parse(contractRaw));
         const trace = context.verificationTrace;
         const verificationTargets = (trace?.targets ?? []).map((target) => ({
+            mode: contract.verificationTargets.find((entry) => entry.id === target.id)?.mode ?? "static",
             status: target.status === "ok" ? "ok" : "failed",
         }));
         const mockEvidenceBound = contract.mockApi.strategy !== "not-needed" &&

package/dist/shared/pi-context-pressure/extension.js

@@ -1,3 +1,4 @@
+import { shouldRewriteAssistantTransientProviderError } from "../pi-provider-recovery.js";
 import { buildOverflowCheckpoint } from "./checkpoint.js";
 import { shouldRewriteAssistantOverflow } from "./overflow.js";
 import { clearRetrieveBypass, compressProviderPayload, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, } from "./sift-bridge.js";
@@ -11,35 +12,44 @@ export function createCompactionController() {
 export function createContextPressureExtension(options) {
     const l2 = options.policy.mode !== "off";
     const l1 = Boolean(options.sift);
-    if (!l2 && !l1)
+    const transientRecovery = options.normalizeTransientProviderErrors === true;
+    if (!l2 && !l1 && !transientRecovery)
         return undefined;
     return {
         name: options.name ?? "operator-chat-context-pressure",
         hidden: true,
         factory: (api) => {
-            if (l2) {
+            if (l2 || transientRecovery) {
                 api.on("message_end", (event) => {
                     const message = event.message;
                     if (!message || typeof message !== "object")
                         return undefined;
                     const rec = message;
-                    if (typeof rec.errorMessage === "string") {
-                        options.controller.lastError = rec.errorMessage;
+                    if (l2) {
+                        if (typeof rec.errorMessage === "string") {
+                            options.controller.lastError = rec.errorMessage;
+                        }
+                        if (rec.role === "assistant") {
+                            clearRetrieveBypassIfPresent(options.sift);
+                        }
+                        const rewritten = shouldRewriteAssistantOverflow(message);
+                        if (rewritten) {
+                            incrementCounter(options.controller.counters, "overflow");
+                            return {
+                                message: {
+                                    ...rec,
+                                    errorMessage: rewritten,
+                                },
+                            };
+                        }
                     }
-                    if (rec.role === "assistant") {
-                        clearRetrieveBypassIfPresent(options.sift);
+                    if (transientRecovery) {
+                        return shouldRewriteAssistantTransientProviderError(message);
                     }
-                    const rewritten = shouldRewriteAssistantOverflow(message);
-                    if (!rewritten)
-                        return undefined;
-                    incrementCounter(options.controller.counters, "overflow");
-                    return {
-                        message: {
-                            ...rec,
-                            errorMessage: rewritten,
-                        },
-                    };
+                    return undefined;
                 });
+            }
+            if (l2) {
                 api.on("session_before_compact", (event) => {
                     const reason = event.reason;
                     if (reason === "overflow") {

package/dist/shared/pi-provider-recovery.js

@@ -0,0 +1,182 @@
+import { buildGeneratedOverflowClassifierSource, isContextOverflow, } from "./pi-context-pressure/overflow.js";
+export const NORMALIZED_TRANSIENT_PROVIDER_PREFIX = "provider returned error:";
+const ERROR_TEXT_LIMIT = 1_500;
+const PERMANENT_ERROR_PATTERNS = [
+    /\b(?:401|403|429)\b|unauthori[sz]ed|forbidden|authentication|invalid api[-_ ]?key|认证错误|鉴权失败/i,
+    /\b(?:quota|billing|insufficient.?credit|out of budget)\b|余额不足|配额(?:不足|耗尽)/i,
+    /rate.?limit|too many requests|请求.{0,8}(?:频繁|过多)|频率.{0,8}限制|限流/i,
+    /aborted by user|user cancel|cancelled|canceled|用户取消/i,
+    /business validation|invalid task|schema validation|业务校验/i,
+];
+export const BUILT_IN_TRANSIENT_PROVIDER_RULES = Object.freeze([
+    Object.freeze({
+        id: "wrapped-transient-provider-error",
+        all: Object.freeze([
+            /\b(?:UnknownError|TypeValidationError)\b|Type validation failed/i,
+        ]),
+        any: Object.freeze([
+            /\b502\b|\bcode[:\s]*502\b/i,
+            /\bLLMRequestError\b/i,
+            /network fluctuation|timeout|model processing timeout/i,
+            /网络波动|模型处理超时|当前请求超时/i,
+            /transient provider failure|non-standard (?:payload|response)|upstream returned/i,
+        ]),
+    }),
+    Object.freeze({
+        id: "internal-llm-request-error",
+        all: Object.freeze([/\bLLMRequestError\b/i]),
+        any: Object.freeze([
+            /\b502\b|\bcode[:\s]*502\b/i,
+            /network fluctuation|timeout|model processing timeout/i,
+            /网络波动|模型处理超时|当前请求超时/i,
+            /non-standard (?:payload|response)|upstream returned/i,
+        ]),
+    }),
+    Object.freeze({
+        id: "internal-provider-fluctuation",
+        any: Object.freeze([/网络波动|模型处理超时|当前请求超时/i]),
+    }),
+]);
+function stringifyErrorPart(value) {
+    if (typeof value === "string")
+        return value;
+    if (value == null)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function errorText(error) {
+    if (typeof error === "string")
+        return error;
+    if (error == null)
+        return "";
+    if (typeof error !== "object")
+        return String(error);
+    const record = error;
+    return [
+        stringifyErrorPart(record.name),
+        stringifyErrorPart(record.message),
+        stringifyErrorPart(record.status),
+        stringifyErrorPart(record.code),
+        stringifyErrorPart(record.data),
+        stringifyErrorPart(error),
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+function patternMatches(pattern, text) {
+    pattern.lastIndex = 0;
+    const matched = pattern.test(text);
+    pattern.lastIndex = 0;
+    return matched;
+}
+function ruleMatches(rule, text) {
+    const all = rule.all ?? [];
+    const any = rule.any ?? [];
+    if (all.length === 0 && any.length === 0)
+        return false;
+    if (!all.every((pattern) => patternMatches(pattern, text)))
+        return false;
+    return any.length === 0 || any.some((pattern) => patternMatches(pattern, text));
+}
+function isPermanentProviderError(error, text) {
+    if (isContextOverflow(error))
+        return true;
+    return PERMANENT_ERROR_PATTERNS.some((pattern) => patternMatches(pattern, text));
+}
+export function classifyTransientProviderError(error, options = {}) {
+    const text = errorText(error);
+    if (!text || isPermanentProviderError(error, text)) {
+        return { retryable: false, reason: "permanent" };
+    }
+    const rules = [
+        ...BUILT_IN_TRANSIENT_PROVIDER_RULES,
+        ...(options.additionalRules ?? []),
+    ];
+    const matched = rules.find((rule) => ruleMatches(rule, text));
+    return matched
+        ? { retryable: true, ruleId: matched.id }
+        : { retryable: false, reason: "no-match" };
+}
+export function normalizeTransientProviderErrorMessage(current, options = {}) {
+    if (!current || current.startsWith(NORMALIZED_TRANSIENT_PROVIDER_PREFIX)) {
+        return undefined;
+    }
+    if (!classifyTransientProviderError(current, options).retryable)
+        return undefined;
+    const bounded = current.length <= ERROR_TEXT_LIMIT
+        ? current
+        : `${current.slice(0, ERROR_TEXT_LIMIT - 1)}…`;
+    return `${NORMALIZED_TRANSIENT_PROVIDER_PREFIX} ${bounded}`;
+}
+export function shouldRewriteAssistantTransientProviderError(message, options = {}) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    const record = message;
+    if (record.role !== "assistant")
+        return undefined;
+    if (record.stopReason !== undefined && record.stopReason !== "error") {
+        return undefined;
+    }
+    const current = typeof record.errorMessage === "string" ? record.errorMessage : "";
+    const rewritten = normalizeTransientProviderErrorMessage(current, options);
+    return rewritten
+        ? { message: { ...record, errorMessage: rewritten } }
+        : undefined;
+}
+function serializePatterns(patterns) {
+    return JSON.stringify(patterns.map((pattern) => ({ source: pattern.source, flags: pattern.flags })));
+}
+/** Generate the pure predicate embedded in the project-level OpenCode plugin. */
+export function buildGeneratedTransientProviderClassifierSource() {
+    const rules = BUILT_IN_TRANSIENT_PROVIDER_RULES.map((rule) => ({
+        id: rule.id,
+        all: (rule.all ?? []).map((pattern) => ({
+            source: pattern.source,
+            flags: pattern.flags,
+        })),
+        any: (rule.any ?? []).map((pattern) => ({
+            source: pattern.source,
+            flags: pattern.flags,
+        })),
+    }));
+    return `${buildGeneratedOverflowClassifierSource()}
+const TRANSIENT_PROVIDER_PERMANENT_PATTERNS = ${serializePatterns(PERMANENT_ERROR_PATTERNS)};
+const TRANSIENT_PROVIDER_RULES = ${JSON.stringify(rules)};
+function transientProviderStringify(value) {
+  if (typeof value === "string") return value;
+  if (value == null) return "";
+  try { return JSON.stringify(value); } catch { return String(value); }
+}
+function transientProviderText(error) {
+  if (typeof error === "string") return error;
+  if (error == null) return "";
+  if (typeof error !== "object") return String(error);
+  return [
+    transientProviderStringify(error.name),
+    transientProviderStringify(error.message),
+    transientProviderStringify(error.status),
+    transientProviderStringify(error.code),
+    transientProviderStringify(error.data),
+    transientProviderStringify(error),
+  ].filter(Boolean).join(" ");
+}
+function transientProviderPatternMatches(pattern, text) {
+  return new RegExp(pattern.source, pattern.flags).test(text);
+}
+function transientProviderRuleMatches(rule, text) {
+  if (rule.all.length === 0 && rule.any.length === 0) return false;
+  if (!rule.all.every((pattern) => transientProviderPatternMatches(pattern, text))) return false;
+  return rule.any.length === 0 || rule.any.some((pattern) => transientProviderPatternMatches(pattern, text));
+}
+function isKnownTransientProviderError(error) {
+  const text = transientProviderText(error);
+  if (!text || isOverflowMessage(text)) return false;
+  if (TRANSIENT_PROVIDER_PERMANENT_PATTERNS.some((pattern) => transientProviderPatternMatches(pattern, text))) return false;
+  return TRANSIENT_PROVIDER_RULES.some((rule) => transientProviderRuleMatches(rule, text));
+}`;
+}

package/dist/shared/pi-retry-settings.js

@@ -21,3 +21,43 @@ export const PI_RECOMMENDED_RETRY = {
     },
 };
 export const PI_RECOMMENDED_COMPACTION = { enabled: true };
+function validBoolean(value) {
+    return typeof value === "boolean";
+}
+function validNonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function preferredOptionalNonNegativeNumber(...values) {
+    return values.find(validNonNegativeNumber);
+}
+function preferredValue(projectValue, globalValue, fallback, isValid) {
+    if (isValid(projectValue))
+        return projectValue;
+    if (isValid(globalValue))
+        return globalValue;
+    return fallback;
+}
+/**
+ * Apply Console-owned retry defaults without writing settings files.
+ * Explicit project fields win over global fields, which win over defaults.
+ */
+export function applyProcessRetryOverride(manager) {
+    if (!manager?.applyOverrides)
+        return { applied: false };
+    const project = manager.getProjectSettings?.()?.retry;
+    const global = manager.getGlobalSettings?.()?.retry;
+    const currentProvider = manager.getProviderRetrySettings?.();
+    const timeoutMs = preferredOptionalNonNegativeNumber(project?.provider?.timeoutMs, global?.provider?.timeoutMs, currentProvider?.timeoutMs);
+    const retry = {
+        enabled: preferredValue(project?.enabled, global?.enabled, PI_RECOMMENDED_RETRY.enabled, validBoolean),
+        maxRetries: preferredValue(project?.maxRetries, global?.maxRetries, PI_RECOMMENDED_RETRY.maxRetries, validNonNegativeNumber),
+        baseDelayMs: preferredValue(project?.baseDelayMs, global?.baseDelayMs, PI_RECOMMENDED_RETRY.baseDelayMs, validNonNegativeNumber),
+        provider: {
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+            maxRetries: preferredValue(project?.provider?.maxRetries, global?.provider?.maxRetries, PI_RECOMMENDED_RETRY.provider.maxRetries, validNonNegativeNumber),
+            maxRetryDelayMs: preferredValue(project?.provider?.maxRetryDelayMs, global?.provider?.maxRetryDelayMs, PI_RECOMMENDED_RETRY.provider.maxRetryDelayMs, validNonNegativeNumber),
+        },
+    };
+    manager.applyOverrides({ retry });
+    return { applied: true, retry };
+}

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

@@ -1,15 +1,11 @@
 /**
  * Pure URL policy for the Operator Chat browser panel: normalize user input
- * into an http(s) URL and refuse destinations that would be dangerous to
- * embed in the panel iframe. Dependency-free so it is unit-testable.
+ * into an http(s) URL. Dependency-free so it is unit-testable.
  *
- * The iframe sandbox (opaque origin — no allow-same-origin, no top
- * navigation) is the primary security boundary; this module is the
- * address-bar gate on top of it: only http/https may be navigated, and
- * loopback addresses are refused so a browsed page cannot probe local
- * services by user action. The Console's OWN origin is explicitly allowed —
- * the sandbox still renders it in an opaque origin with no same-origin
- * privileges, exactly like any other site.
+ * Only the scheme is gated: javascript:, data:, file: and friends must never
+ * reach the iframe. Local addresses (localhost / 127.0.0.1 / ::1 / LAN
+ * hosts) are deliberately allowed — the panel is a development console and
+ * its users routinely browse local dev servers.
  */
 /**
  * Extract the `frame-ancestors` source list of a Content-Security-Policy
@@ -47,16 +43,6 @@ export function embeddabilityOf(probe) {
     }
     return "embeddable";
 }
-/** A loopback hostname (localhost, IPv6 ::1, 127.0.0.0/8, 0.0.0.0). */
-export function isLoopbackHostname(hostname) {
-    const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
-    if (host === "localhost" || host === "::1" || host === "0.0.0.0")
-        return true;
-    const parts = host.split(".");
-    return (parts.length === 4 &&
-        parts[0] === "127" &&
-        parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255));
-}
 /**
  * Schemes that must never reach the iframe even without `//` (javascript:,
  * data:, file:, ...). Host:port lookalikes (example.com:8080) are NOT here —
@@ -88,12 +74,8 @@ const FORBIDDEN_SCHEMES = new Set([
 /**
  * Normalize one address-bar input against the navigation policy.
  * @param input raw user text.
- * @param selfOrigin the Console's own origin (window.location.origin). The
- * Console itself may be browsed in the panel (the sandbox keeps it opaque),
- * so it is let through BEFORE the loopback check — its host is normally
- * loopback.
  */
-export function normalizeBrowserUrl(input, selfOrigin) {
+export function normalizeBrowserUrl(input) {
     const trimmed = input.trim();
     if (trimmed === "")
         return { kind: "invalid" };
@@ -127,17 +109,5 @@ export function normalizeBrowserUrl(input, selfOrigin) {
     if (url.protocol !== "http:" && url.protocol !== "https:") {
         return { kind: "blocked", reason: "scheme" };
     }
-    // The Console's own origin is allowed (browsed in an opaque origin like
-    // any other site); checked before the loopback gate because its host is
-    // normally loopback.
-    try {
-        if (url.origin === new URL(selfOrigin).origin)
-            return { kind: "ok", url: url.href };
-    }
-    catch {
-        // Unparsable selfOrigin (never in practice): fall through to the gate.
-    }
-    if (isLoopbackHostname(url.hostname))
-        return { kind: "blocked", reason: "loopback" };
     return { kind: "ok", url: url.href };
 }