pi-web-ui 0.94.1 → 0.96.0

package/dist/server/goal-service.js

@@ -12,11 +12,111 @@
  * 结构化子集 GoalConversation 传入（真实 Conversation 满足该结构），会话创建/对话框
  * 取消/git diff 等宿主能力走回调，便于独立测试。UI 文案直接中文（服务端 notice 约定）。
  */
+import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { Type } from "typebox";
 import { createAgentSessionFromServices, createAgentSessionServices, defineTool, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
-import { bilingual, pick } from "./i18n.js";
+import { pick } from "./i18n.js";
 import { parseModelSpec } from "./attachments.js";
+/**
+ * 自主模式完成标记（与注入对话的【目标…】约定严格一致）：
+ *  - 【目标已达成】/【目标完成】/【目标达成】——必须带全角括号；
+ *  - GOAL 后必须跟至少一个分隔符（冒号/下划线/空白）且 COMPLETED/PASSED 为整词。
+ * 刻意不收裸子串（如「目标已达成」不带括号）：模型在计划、复述目标或假设句里
+ * 也会写出这些字样（"如果测试全绿则目标已达成"），裸匹配会把中间轮误判成 pass。
+ */
+const GOAL_COMPLETION_RE = /【目标(?:已)?(?:达成|完成)】|(?<![A-Za-z])GOAL(?:[:：_]|\s+)+(?:IS\s+)?(?:COMPLETED|PASSED)(?![A-Za-z])/i;
+/** 自主轮次完成信号判定（纯函数，供 runGoalReview 与单测共用）。 */
+export function isGoalCompletionSignal(finalText) {
+    return GOAL_COMPLETION_RE.test(finalText);
+}
+/** 提取 raw 中第一个括号平衡的 {...} 子串（字符串字面量内的引号/转义/花括号不参与配对）。 */
+function firstBalancedJsonObject(raw) {
+    const start = raw.indexOf("{");
+    if (start < 0)
+        return undefined;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < raw.length; i++) {
+        const ch = raw[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "{")
+            depth++;
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0)
+                return raw.slice(start, i + 1);
+        }
+    }
+    return undefined;
+}
+/**
+ * 解析审查模型的 verdict 输出（纯函数）。优先取第一个平衡 {...} 做 JSON.parse：
+ * 模型常包 markdown 围栏或前后闲话，feedback 里也可能有 \" 转义与嵌套引号，
+ * 这些由 JSON 语义天然处理；整体解析失败（单引号/尾逗号等）再退回旧的宽松
+ * 正则逐字段抠。两者都失败返回 undefined，调用方按「无 JSON」处理。
+ */
+export function parseReviewerVerdict(raw) {
+    const json = firstBalancedJsonObject(raw);
+    if (json !== undefined) {
+        try {
+            const value = JSON.parse(json);
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                if (value.verdict === "pass" || value.verdict === "fail") {
+                    return { verdict: value.verdict, feedback: typeof value.feedback === "string" ? value.feedback : "" };
+                }
+            }
+        }
+        catch {
+            // 不是合法 JSON（围栏残留/单引号/尾逗号）→ 落到正则兜底
+        }
+    }
+    const m = raw.match(/\{\s*"verdict"\s*:\s*"(pass|fail)"[^}]*\}/);
+    if (m) {
+        const fm = raw.match(/"feedback"\s*:\s*"([^"]*)"/);
+        return { verdict: m[1], feedback: fm?.[1] ?? "" };
+    }
+    return undefined;
+}
+/** diff 正文进审查 prompt 的截断上限（完整规模信息走 [diff-meta] 尾段）。 */
+export const GIT_DIFF_CAP = 60_000;
+/**
+ * 由 git 原始输出构造「变更指纹」（纯函数，供 AgentService.gitDiff 与单测共用）。
+ *  - diff 正文非空 → 截断正文 + [diff-meta] 尾段（完整字符数 + 排序后的 status
+ *    指纹）。尾段永不参与截断：大 diff 两轮的前 60_000 字符可能完全相同（改动
+ *    落在截断线之后），只比截断正文会把持续推进误判成停滞；对内容变化敏感的
+ *    完整字符数让 prevDiff 等值比较能区分「真没变」与「变了但被截断」。
+ *  - diff 正文为空 → 排序后的 `git status --porcelain` 指纹（未跟踪文件不进
+ *    diff，却是新工作区最常见的实际进展）；两段都空（返回 ""）才算真停滞。
+ *  - status 输出为空/拍不到 → 对应段省略，退化为旧版纯 diff 行为。
+ */
+export function buildDiffFingerprint(diffOut, statusOut) {
+    let status = "";
+    if (statusOut.trim() !== "") {
+        // porcelain 不承诺输出有序，显式排序保证指纹逐轮稳定可比。
+        status = statusOut
+            .split("\n")
+            .filter((line) => line.trim() !== "")
+            .sort()
+            .join("\n")
+            .slice(0, 20_000);
+    }
+    if (diffOut.trim() === "")
+        return status;
+    const meta = `\n[diff-meta] chars=${diffOut.length}${status ? `\n[git-status]\n${status}` : ""}`;
+    return diffOut.slice(0, GIT_DIFF_CAP) + meta;
+}
 /** System prompt for the goal-wizard session. The wizard asks the user a few
  *  questions (via its goal_ask tool) to scope a raw requirement into a precise,
  *  reviewable goal, then emits ONLY the final goal text as its last message. */
@@ -27,8 +127,11 @@ function wizardPrompt(draft) {
         `# User's raw requirement`, // eslint-disable-line no-regex-spaces
         draft,
         ``,
-        `Use your goal_ask tool to ask the user focused questions to pin down the essential, ambiguous details. Keep it concise — usually 2 to 4 questions: what exactly to build/do, scope boundaries (what NOT to do), acceptance criteria / done-definition, and any constraints (style, performance, environment).`, // eslint-disable-line max-len
-        `Prefer multiple-choice (goal_ask with options) when you can offer clear choices; use open questions only for things that genuinely need free text.`, // eslint-disable-line max-len
+        `Use your goal_ask tool to ask the user focused questions to pin down the essential, ambiguous details.`,
+        `Convergence guidelines:`,
+        `- Ask ONE question at a time, strictly 1 to 3 questions total: what exactly to build/do, scope boundaries (what NOT to do), acceptance criteria / done-definition, and any constraints (style, performance, environment).`, // eslint-disable-line max-len
+        `- Prefer multiple-choice with 2-4 mutually exclusive options and place your recommended choice FIRST.`,
+        `- In each option, concisely explain the impact or tradeoff. Use open questions only for things that genuinely need free text.`, // eslint-disable-line max-len
         `Once you have enough to write an unambiguous, reviewable goal, STOP asking and reply with EXACTLY this format and nothing else (no preamble, no bullets):`, // eslint-disable-line max-len
         `GOAL: <one concrete, verifiable sentence describing the deliverable and its acceptance criteria>`, // eslint-disable-line max-len
         `If the user cancels or stops answering (the tool reports a cancellation), still produce a sensible best-effort goal from what you already know.`, // eslint-disable-line max-len
@@ -122,6 +225,12 @@ export class GoalService {
      * Set (or clear) the active goal. `goal === ""` clears it. The goal is
      * applied to the CURRENT active conversation of this project; reviews check
      * whatever run finishes next (agent_end).
+     *
+     * `opts.targetConvId` retargets the write to a specific conversation — used by
+     * the goal wizard, which runs in the background while the user may have
+     * switched away: the refined goal must land in the conversation that LAUNCHED
+     * the survey (issue #292), not in whatever conversation happens to be active
+     * and not be thrown away.
      */
     async setGoal(goalText, opts) {
         const text = (goalText ?? "").trim();
@@ -138,11 +247,23 @@ export class GoalService {
             });
             return;
         }
-        // A goal is scoped to the conversation that is active when it is set.
-        // This prevents an agent_end from a newly-created/switched conversation
+        // A goal is scoped to the conversation it is set on (default: the active
+        // one). This prevents an agent_end from a newly-created/switched conversation
         // from consuming the previous conversation's goal.
-        const conv = this.host.activeConv();
-        const goalConversationId = this.host.activeConvId();
+        const targetConv = opts?.targetConvId ? this.host.getConv(opts.targetConvId) : undefined;
+        if (opts?.targetConvId && !targetConv) {
+            // The targeted conversation is gone (closed / disposed) — refuse loudly
+            // instead of silently landing the goal somewhere else.
+            this.host.emit({
+                type: "notice",
+                level: "warning",
+                text: `目标未设置：发起目标调研的对话已关闭。`,
+                textEn: `Goal not set: the conversation that started the survey is gone.`,
+            });
+            return;
+        }
+        const conv = targetConv ?? this.host.activeConv();
+        const goalConversationId = conv.id;
         conv.goalGeneration += 1;
         const goal = conv.goal;
         goal.reviewing = false;
@@ -171,6 +292,10 @@ export class GoalService {
             locked: goal.locked,
         });
         // Reset the loop for a freshly-set goal (single-shot goals start at 0).
+        conv.stagnantRounds = 0;
+        conv.lastDiff = undefined;
+        conv.lastErrorSnippet = undefined;
+        conv.sameErrorRounds = 0;
         goal.round = 0;
         goal.reviewing = false;
         goal.verdict = "pending";
@@ -232,6 +357,9 @@ export class GoalService {
         // new active conversation while the wizard is still finishing.
         const wizardConversationId = this.host.activeConvId();
         const wizardConversation = this.host.activeConv();
+        // Human-readable name for notices that must say WHICH conversation the survey
+        // belongs to (issue #292: the user is expected to switch away mid-survey).
+        const wizardConversationTitle = wizardConversation.title;
         if (wizardConversation.wizardRunning || this.wizardOwnerId !== null) {
             this.host.emit({
                 type: "notice",
@@ -329,7 +457,16 @@ export class GoalService {
         });
         // The main conversation to show wizard progress cards in.
         const mainSession = wizardConversation.session;
+        // The raw draft gets its own read-only card BEFORE the first question, so the
+        // flow starts from a visible anchor. If the survey is interrupted (idle/total
+        // timeout, ✗, or the user switching away and never coming back), the original
+        // requirement is still readable and copyable in THIS conversation instead of
+        // having to be retyped (issue #292).
+        await this.pushWizardCard(mainSession, pick(this.lang(), `🎯 原始目标草案：${draft}`, `🎯 Initial goal draft: ${draft}`, "goal.wizard.draft.card", {
+            draft,
+        }), { draft });
         let refinedGoal = "";
+        let goalEphemeralDir;
         try {
             const wmSpec = opts?.wizardModel ? this.resolveReviewModel(opts.wizardModel) : null; // reuse the honest "provider/id" parser
             const services = await createAgentSessionServices({
@@ -354,10 +491,14 @@ export class GoalService {
             const goalAsk = defineTool({
                 name: "goal_ask",
                 label: "Ask the user",
-                description: bilingual("Ask the user ONE question at a time to scope down the goal. Provide a clear question and 2-4 concise options; or ask an open question. Returns the user's chosen answer.", "一次只向用户提一个问题，以明确目标范围。给出清晰的问题和 2-4 个简洁选项；或提开放式问题。返回用户选择的答案。"),
+                description: "Ask the user ONE focused question at a time to scope down the goal. " +
+                    "Provide 2-4 mutually exclusive options with the recommended option first, " +
+                    "briefly noting its impact or tradeoff; or ask an open question. Returns the user's chosen answer.",
                 parameters: Type.Object({
-                    question: Type.String({ description: bilingual("The question to ask", "要问的问题") }),
-                    options: Type.Optional(Type.Array(Type.String())),
+                    question: Type.String({ description: "The question to ask" }),
+                    options: Type.Optional(Type.Array(Type.String(), {
+                        description: "2-4 mutually exclusive options (recommended option first)",
+                    })),
                 }),
                 // ONE question at a time. Sequential execution prevents the agent from
                 // firing parallel goal_ask calls whose dialogs would overwrite each other
@@ -463,9 +604,16 @@ export class GoalService {
                     }
                 },
             });
+            const sm = SessionManager.inMemory(this.host.cwd());
+            goalEphemeralDir = join(services.agentDir, "goal-sessions", `wizard-${Date.now()}`);
+            try {
+                mkdirSync(goalEphemeralDir, { recursive: true });
+                sm.sessionDir = goalEphemeralDir;
+            }
+            catch { }
             const srv = await createAgentSessionFromServices({
                 services,
-                sessionManager: SessionManager.inMemory(this.host.cwd()),
+                sessionManager: sm,
                 customTools: [goalAsk],
                 ...(model ? { model } : {}),
             });
@@ -517,15 +665,25 @@ export class GoalService {
             wgoal.wizard.status = "";
             wgoal.wizard.statusEn = "";
             this.wizardSession = null;
+            if (goalEphemeralDir) {
+                try {
+                    rmSync(goalEphemeralDir, { recursive: true, force: true });
+                }
+                catch { }
+            }
             this.emitGoalStatus();
         }
-        // Aborted externally (✗ / clear_goal / idle-timeout): do NOT set a goal.
+        // Aborted externally (✗ / clear_goal / idle-timeout): do NOT set a goal. The raw
+        // draft card stays in the launching conversation's flow, so the user can read
+        // it back (and retry) instead of having to retype it (issue #292).
         if (ac.signal.aborted || this.wizardCancelled) {
             this.host.emit({
                 type: "notice",
                 level: "info",
-                text: `目标调研已取消${ac.signal.reason ? `：${String(ac.signal.reason?.message ?? ac.signal.reason)}` : ""}`,
-                textEn: `Goal survey cancelled${ac.signal.reason ? `: ${String(ac.signal.reason?.message ?? ac.signal.reason)}` : ""}`,
+                text: `目标调研已取消${ac.signal.reason ? `：${String(ac.signal.reason?.message ?? ac.signal.reason)}` : ""}` +
+                    `。原始目标草案已保留在会话「${wizardConversationTitle}」的消息流中，可复制后重新发起。`,
+                textEn: `Goal survey cancelled${ac.signal.reason ? `: ${String(ac.signal.reason?.message ?? ac.signal.reason)}` : ""}` +
+                    `. The initial goal draft is preserved in the conversation "${wizardConversationTitle}" — copy it and start over.`,
             });
             this.wizardAbort = null;
             return;
@@ -534,20 +692,26 @@ export class GoalService {
             this.host.emit({
                 type: "notice",
                 level: "warning",
-                text: "调研未产出有效目标，请重试",
-                textEn: "The survey produced no usable goal — retry",
+                text: `调研未产出有效目标，请重试（原始目标草案在会话「${wizardConversationTitle}」的消息流中）`,
+                textEn: `The survey produced no usable goal — retry (the initial draft is in the conversation "${wizardConversationTitle}")`,
             });
             return;
         }
-        if (this.host.activeConvId() !== wizardConversationId) {
+        // The survey belongs to the conversation that launched it. The user is EXPECTED
+        // to switch away while the questions are being answered (check code, read docs),
+        // so "active ≠ launcher" is the normal case, not an error: land the refined goal
+        // on the launcher instead of discarding the work (issue #292).
+        const targetConv = this.host.getConv(wizardConversationId);
+        if (!targetConv) {
             this.host.emit({
                 type: "notice",
-                level: "info",
-                text: "已切换对话，目标调研结果已丢弃",
-                textEn: "Switched conversations; the survey result was discarded",
+                level: "warning",
+                text: `目标调研完成，但发起会话「${wizardConversationTitle}」已关闭，结果未应用（可在新会话里重新发起）。`,
+                textEn: `The survey finished, but the conversation that started it ("${wizardConversationTitle}") is gone — the result was not applied. Start a new survey.`,
             });
             return;
         }
+        const switchedAway = this.host.activeConvId() !== wizardConversationId;
         // Auto-set the refined goal. The wizard workflow implies "set a goal and
         // work until it passes", so default LOCKED=true unless the user explicitly
         // turned the lock off (a lock lets the review loop keep revising to pass;
@@ -557,6 +721,9 @@ export class GoalService {
             reviewModel: wgoal.reviewModel ?? undefined,
             maxRounds: opts?.maxRounds,
             locked: wantLocked,
+            // Land the goal on the conversation that launched the survey, even if the
+            // user is looking at another one right now (issue #292).
+            targetConvId: wizardConversationId,
             // The wizard kicks off generation itself below — avoid a double kick.
             autoStart: false,
         });
@@ -565,8 +732,12 @@ export class GoalService {
         this.host.emit({
             type: "notice",
             level: "info",
-            text: `🎯 调研完成，目标已设为：${refinedGoal.slice(0, 80)}${refinedGoal.length > 80 ? "…" : ""}`,
-            textEn: `🎯 Survey done, goal set: ${refinedGoal.slice(0, 80)}${refinedGoal.length > 80 ? "…" : ""}`,
+            text: switchedAway
+                ? `🎯 会话「${wizardConversationTitle}」目标调研完成，目标已设为：${refinedGoal.slice(0, 80)}${refinedGoal.length > 80 ? "…" : ""}（已切回该会话开始生成）`
+                : `🎯 调研完成，目标已设为：${refinedGoal.slice(0, 80)}${refinedGoal.length > 80 ? "…" : ""}`,
+            textEn: switchedAway
+                ? `🎯 Survey done in "${wizardConversationTitle}", goal set: ${refinedGoal.slice(0, 80)}${refinedGoal.length > 80 ? "…" : ""} (switch back to that conversation to watch it generate)`
+                : `🎯 Survey done, goal set: ${refinedGoal.slice(0, 80)}${refinedGoal.length > 80 ? "…" : ""}`,
         });
         // Kick the main agent into generating right away (no manual "开始吧").
         // The kick-off is a user message so it appears in the flow and triggers a
@@ -613,6 +784,10 @@ export class GoalService {
     async clearGoal() {
         const conv = this.host.activeConv();
         conv.goalGeneration += 1;
+        conv.stagnantRounds = 0;
+        conv.lastDiff = undefined;
+        conv.lastErrorSnippet = undefined;
+        conv.sameErrorRounds = 0;
         const goal = conv.goal;
         goal.reviewing = false;
         goal.conversationId = null;
@@ -652,6 +827,10 @@ export class GoalService {
         if (aborted) {
             if (g.goal && g.conversationId === conv.id) {
                 conv.goalGeneration += 1;
+                conv.stagnantRounds = 0;
+                conv.lastDiff = undefined;
+                conv.lastErrorSnippet = undefined;
+                conv.sameErrorRounds = 0;
                 g.conversationId = null;
                 g.goal = null;
                 g.reviewing = false;
@@ -670,9 +849,12 @@ export class GoalService {
         // Goal review hook: after the run finished normally, if a goal is
         // active (and it belonged to the ACTIVE conversation) and we're not
         // already mid-review, spawn the isolated reviewer.
+        // Only run when verdict is pending — failed/blocked terminal goals must not
+        // re-trigger reviews on subsequent unrelated conversational turns.
         if (g.goal &&
             g.conversationId === conv.id &&
             !g.reviewing &&
+            g.verdict === "pending" &&
             !conv.wizardRunning &&
             !this.host.isDisposed() &&
             this.goalEnabled()) {
@@ -684,6 +866,38 @@ export class GoalService {
     resolveReviewModel(spec) {
         return parseModelSpec(spec);
     }
+    /** 提取会话最近产生的错误特征，用于停滞与相同报错检测。 */
+    extractErrorSnippet(session, text) {
+        try {
+            const messages = session.agent?.state?.messages;
+            if (Array.isArray(messages)) {
+                for (let i = messages.length - 1; i >= 0 && i >= messages.length - 6; i--) {
+                    const m = messages[i];
+                    if (m.role === "toolResult" && m.isError) {
+                        const errText = m.content
+                            ?.map((c) => (c.type === "text" ? c.text : ""))
+                            .join(" ")
+                            .trim();
+                        if (errText)
+                            return errText.slice(0, 300);
+                    }
+                    if (m.role === "bashExecution" && m.exitCode && m.exitCode !== 0) {
+                        const snippet = m.output?.trim().slice(-300);
+                        if (snippet)
+                            return `bash exit ${m.exitCode}: ${snippet}`;
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore
+        }
+        const errMatch = text.match(/(?:(?:Error|Exception|Fail|Fatal):[^\n]+)/i);
+        if (errMatch) {
+            return errMatch[0].trim().slice(0, 300);
+        }
+        return undefined;
+    }
     /**
      * The whitelisted reviewer plan — tell the reviewer what to decide and how
      * to report, regardless of which model it runs on.
@@ -798,65 +1012,121 @@ export class GoalService {
         }
         let reviewerVerdict = "fail";
         let reviewerFeedback = pick(this.lang(), "（审查无法完成）", "(The review could not be completed)", "goal.review.incomplete");
-        try {
-            const rmSpec = this.resolveReviewModel(g.reviewModel);
-            const services = await createAgentSessionServices({
-                cwd: mainConv.cwd,
-                agentDir: this.host.agentDir,
-                // The reviewer has its own skill allow/deny list. It deliberately does
-                // not reuse the main session's disabledSkills setting.
-                resourceLoaderOptions: {
-                    skillsOverride: (res) => ({
-                        ...res,
-                        skills: res.skills.filter((s) => !reviewDisabledSkills.has(s.name)),
-                    }),
-                },
-                // A FRESH ModelRuntime for the reviewer — isolated from the shared
-                // one used by the main conversations, so its model choice is its own.
-                modelRuntime: await ModelRuntime.create({
-                    authPath: join(this.host.agentDir, "auth.json"),
-                    modelsPath: join(this.host.agentDir, "models.json"),
-                }),
-            });
-            // Model resolution: explicit reviewer model, else the main session's
-            // current model (so a goal works even when no reviewer model is given).
-            let model;
-            if (rmSpec) {
-                model = services.modelRuntime.getModel(rmSpec.provider, rmSpec.id);
-            }
-            if (!model) {
-                const mainModel = mainSession.model;
-                if (mainModel?.provider && mainModel.id) {
-                    model = services.modelRuntime.getModel(mainModel.provider, mainModel.id);
-                }
+        // 停滞与错误检测分析（DSH 风格防死循环与停滞检测）：
+        const currentError = this.extractErrorSnippet(mainSession, finalText);
+        const prevError = conv.lastErrorSnippet;
+        if (currentError &&
+            prevError &&
+            (currentError === prevError || currentError.includes(prevError) || prevError.includes(currentError))) {
+            conv.sameErrorRounds = (conv.sameErrorRounds ?? 0) + 1;
+        }
+        else {
+            conv.sameErrorRounds = currentError ? 1 : 0;
+        }
+        conv.lastErrorSnippet = currentError;
+        const trimmedDiff = diff.trim();
+        const prevDiff = conv.lastDiff;
+        const isNoDiffChange = trimmedDiff === "" || (prevDiff !== undefined && trimmedDiff === prevDiff);
+        if (isNoDiffChange) {
+            conv.stagnantRounds = (conv.stagnantRounds ?? 0) + 1;
+        }
+        else {
+            conv.stagnantRounds = 0;
+        }
+        conv.lastDiff = trimmedDiff;
+        const isAutonomous = !g.reviewModel;
+        if (isAutonomous) {
+            // DSH 风格自主轮次驱动（免拉起独立审查会话，省 token + 零启动延迟）：
+            // 检查模型自身是否在输出中表明目标已达成（只认约定标记，见 GOAL_COMPLETION_RE）
+            const isCompleted = isGoalCompletionSignal(finalText);
+            if (isCompleted) {
+                reviewerVerdict = "pass";
+                reviewerFeedback = pick(this.lang(), "模型自主验证：目标已达成", "Model autonomous evaluation: Goal completed", "goal.autonomous.pass");
             }
-            const srv = await createAgentSessionFromServices({
-                services,
-                sessionManager: SessionManager.inMemory(mainConv.cwd),
-                ...(model ? { model } : {}),
-            });
-            const reviewCap = g.locked && g.maxRounds > 0 ? g.maxRounds : 0; // 0 = no cap
-            const reviewer = srv.session;
-            await reviewer.prompt(this.reviewerPrompt(goalText, g.round, reviewCap, finalText, diff, reviewPrompt));
-            // Parse the reviewer's final output (expected to be a JSON object).
-            const raw = reviewer.getLastAssistantText() ?? "";
-            const m = raw.match(/\{\s*"verdict"\s*:\s*"(pass|fail)"[^}]*\}/);
-            if (m) {
-                reviewerVerdict = m[1];
-                const fm = raw.match(/"feedback"\s*:\s*"([^"]*)"/);
-                reviewerFeedback = fm?.[1] ?? "";
+            else if ((conv.sameErrorRounds ?? 0) >= 2 || (conv.stagnantRounds ?? 0) >= 2) {
+                // 触发防死循环与停滞熔断（Blocked）
+                reviewerVerdict = "blocked";
+                const blockedReason = (conv.sameErrorRounds ?? 0) >= 2
+                    ? `连续 ${conv.sameErrorRounds} 轮出现相同错误：${currentError}`
+                    : `连续 ${conv.stagnantRounds} 轮未检测到有效文件修改或实质进展`;
+                const blockedReasonEn = (conv.sameErrorRounds ?? 0) >= 2
+                    ? `Identical error across ${conv.sameErrorRounds} consecutive rounds: ${currentError}`
+                    : `No effective file modifications or progress across ${conv.stagnantRounds} consecutive rounds`;
+                reviewerFeedback = pick(this.lang(), `【目标防死循环保护：执行受阻（Blocked）】\n\n` +
+                    `• 停滞原因：${blockedReason}\n` +
+                    `• 当前轮次：第 ${g.round} 轮\n` +
+                    `• 诊断分析：智能体在自主推进中连续轮次未产生有效进展或反复遭遇相同错误，已自动熔断以防止无谓消耗 token。\n` +
+                    `• 建议措施：请检查相关代码、工具权限或手动调整提示词，排查阻碍后再继续。`, `[Goal Infinite-Loop Protection: Blocked]\n\n` +
+                    `• Cause: ${blockedReasonEn}\n` +
+                    `• Current round: Round ${g.round}\n` +
+                    `• Diagnosis: Agent made no progress or encountered identical errors across consecutive rounds. Circuit breaker tripped to prevent token waste.\n` +
+                    `• Recommendation: Please check code, tool permissions, or refine prompt before proceeding.`, "goal.review.blocked", { blockedReason, blockedReasonEn, round: g.round });
             }
             else {
-                // No JSON — assume fail with the raw output as feedback.
                 reviewerVerdict = "fail";
-                reviewerFeedback = raw.slice(0, 2000);
+                reviewerFeedback = pick(this.lang(), "目标尚未完成，自主推进下一轮迭代验证。", "Goal not yet completed; continuing to next iteration.", "goal.autonomous.continue");
             }
-            await srv.session.dispose();
         }
-        catch (err) {
-            const reviewErrMsg = err.message;
-            reviewerVerdict = "fail";
-            reviewerFeedback = pick(this.lang(), `审查过程中出错：${reviewErrMsg}`, `Error during review: ${reviewErrMsg}`, "goal.review.error", { reviewErrMsg: reviewErrMsg });
+        else {
+            try {
+                const rmSpec = this.resolveReviewModel(g.reviewModel);
+                const services = await createAgentSessionServices({
+                    cwd: mainConv.cwd,
+                    agentDir: this.host.agentDir,
+                    // The reviewer has its own skill allow/deny list. It deliberately does
+                    // not reuse the main session's disabledSkills setting.
+                    resourceLoaderOptions: {
+                        skillsOverride: (res) => ({
+                            ...res,
+                            skills: res.skills.filter((s) => !reviewDisabledSkills.has(s.name)),
+                        }),
+                    },
+                    // A FRESH ModelRuntime for the reviewer — isolated from the shared
+                    // one used by the main conversations, so its model choice is its own.
+                    modelRuntime: await ModelRuntime.create({
+                        authPath: join(this.host.agentDir, "auth.json"),
+                        modelsPath: join(this.host.agentDir, "models.json"),
+                    }),
+                });
+                // Model resolution: explicit reviewer model, else the main session's
+                // current model (so a goal works even when no reviewer model is given).
+                let model;
+                if (rmSpec) {
+                    model = services.modelRuntime.getModel(rmSpec.provider, rmSpec.id);
+                }
+                if (!model) {
+                    const mainModel = mainSession.model;
+                    if (mainModel?.provider && mainModel.id) {
+                        model = services.modelRuntime.getModel(mainModel.provider, mainModel.id);
+                    }
+                }
+                const srv = await createAgentSessionFromServices({
+                    services,
+                    sessionManager: SessionManager.inMemory(mainConv.cwd),
+                    ...(model ? { model } : {}),
+                });
+                const reviewCap = g.locked && g.maxRounds > 0 ? g.maxRounds : 0; // 0 = no cap
+                const reviewer = srv.session;
+                await reviewer.prompt(this.reviewerPrompt(goalText, g.round, reviewCap, finalText, diff, reviewPrompt));
+                // Parse the reviewer's final output (expected to be a JSON object).
+                const raw = reviewer.getLastAssistantText() ?? "";
+                const parsed = parseReviewerVerdict(raw);
+                if (parsed) {
+                    reviewerVerdict = parsed.verdict;
+                    reviewerFeedback = parsed.feedback;
+                }
+                else {
+                    // No JSON — assume fail with the raw output as feedback.
+                    reviewerVerdict = "fail";
+                    reviewerFeedback = raw.slice(0, 2000);
+                }
+                await srv.session.dispose();
+            }
+            catch (err) {
+                const reviewErrMsg = err.message;
+                reviewerVerdict = "fail";
+                reviewerFeedback = pick(this.lang(), `审查过程中出错：${reviewErrMsg}`, `Error during review: ${reviewErrMsg}`, "goal.review.error", { reviewErrMsg: reviewErrMsg });
+            }
         }
         // The user may have switched chats or replaced/cleared the goal while the
         // isolated reviewer was running. Never apply a stale verdict or inject it
@@ -897,12 +1167,37 @@ export class GoalService {
             this.host.flushSnapshot();
             return;
         }
+        if (verdict === "blocked") {
+            g.status = "⚠️ 目标受阻（停滞熔断）";
+            g.statusEn = "⚠️ Goal blocked (stagnation circuit break)";
+            this.host.emit({
+                type: "notice",
+                level: "warning",
+                text: "⚠️ 目标执行受阻：检测到停滞或相同报错，已自动暂停",
+                textEn: "⚠️ Goal execution blocked: stagnation or repeated error detected, auto-loop paused",
+            });
+            try {
+                const blockedText = pick(this.lang(), `⚠️ 目标执行受阻（第 ${round} 轮已触发停滞熔断）。\n\n目标：${goalText}\n\n${feedback}\n\n（目标模式已暂停，请在排查问题后重新设定目标或手动继续。）`, `⚠️ Goal execution blocked (stagnation circuit breaker at round ${round}).\n\nGoal: ${goalText}\n\n${feedback}\n\n(Goal mode paused — please investigate and reset goal or continue manually.)`, "goal.review.blocked_msg", { round, goalText, feedback });
+                await mainSession.sendUserMessage(blockedText, {
+                    deliverAs: mainSession.isStreaming ? "steer" : "followUp",
+                });
+            }
+            catch {
+                // Best-effort.
+            }
+            g.reviewing = false;
+            this.emitGoalStatus();
+            this.host.flushSnapshot();
+            return;
+        }
         // Failure: if rounds remain, steer a revision; else report the loop done.
         // For unlimited (budget=0) isLastRound is always false → keeps revising.
         const isLastRound = !g.locked ? true : g.maxRounds > 0 && g.round >= g.maxRounds;
         if (!isLastRound) {
             g.status = `本轮不通过，正在把意见交给 agent 修改（${roundsZh}）…`;
             g.statusEn = `Round failed, sending feedback to the agent (${roundsEn})…`;
+            // 注入修改意见后保持 verdict 为 pending，让 agent 下一次答完后继续下一轮审查
+            g.verdict = "pending";
             this.host.emit({
                 type: "notice",
                 level: "warning",
@@ -954,8 +1249,7 @@ export class GoalService {
             text: "目标未通过审查（已达最大轮数）",
             textEn: "Goal failed review (max rounds reached)",
         });
-        g.conversationId = null;
-        g.goal = null; // loop exhausted — clear the active goal
+        g.reviewing = false; // 审查结束：保留 g.goal 与 g.conversationId，让用户看到未通过的目标，不丢弃目标文本
         this.emitGoalStatus();
         this.host.flushSnapshot();
     }