pi-web-ui 0.27.1 → 0.28.0

package/dist/server/agent-service.js

@@ -909,6 +909,8 @@ class ClientStateStore {
             visionBridgeModel: s?.settings?.visionBridgeModel ?? null,
             visionBridgePromptMode: s?.settings?.visionBridgePromptMode === "replace" ? "replace" : "append",
             visionBridgePrompt: s?.settings?.visionBridgePrompt ?? "",
+            reviewPrompt: s?.settings?.reviewPrompt ?? "",
+            reviewDisabledSkills: s?.settings?.reviewDisabledSkills ?? [],
         };
     }
     /** Persist the client's settings-panel state (partial merge). */
@@ -927,12 +929,19 @@ class ClientStateStore {
                 cur.visionBridgePromptMode ??
                 "append",
             visionBridgePrompt: settings.visionBridgePrompt ?? cur.visionBridgePrompt ?? "",
+            reviewPrompt: settings.reviewPrompt ?? cur.reviewPrompt ?? "",
+            reviewDisabledSkills: settings.reviewDisabledSkills ?? cur.reviewDisabledSkills ?? [],
         };
         this.save();
     }
     /** Named settings presets for a client (empty if never saved). */
     getPresets(clientId) {
-        return this.load()[clientId]?.presets ?? [];
+        return (this.load()[clientId]?.presets ?? []).map((p) => ({
+            ...p,
+            // Older client-state files predate review settings.
+            reviewPrompt: p.reviewPrompt ?? "",
+            reviewDisabledSkills: p.reviewDisabledSkills ?? [],
+        }));
     }
     /** Persist the client's named settings presets. */
     savePresets(clientId, presets) {
@@ -955,6 +964,102 @@ const TOOL_WATCHDOG_TIMEOUT_MS = (() => {
  *  runtime alive; conversations of other projects keep their own lists). */
 const MAX_OPEN_CONVERSATIONS = 8;
 const DEFAULT_CONV_TITLE = "新对话";
+/** Build the agent-facing persistent terminal tools for one conversation. */
+export function makePersistentTerminalTools(terminals, cwd) {
+    const result = (text, details = {}) => ({ content: [{ type: "text", text }], details });
+    const failIf = (error) => {
+        if (error)
+            throw new Error(error);
+    };
+    return [
+        defineTool({
+            name: "terminal_create",
+            label: "Create terminal",
+            description: "Create a named persistent interactive PTY in the current workspace. Use terminal_input or terminal_key to interact with it and terminal_read to inspect incremental output.",
+            promptSnippet: "create persistent interactive PTY terminals",
+            parameters: Type.Object({
+                terminalId: Type.String({ description: "Stable terminal name" }),
+                cwd: Type.Optional(Type.String({ description: "Workspace-relative directory" })),
+                cols: Type.Optional(Type.Integer({ minimum: 2, maximum: 500 })),
+                rows: Type.Optional(Type.Integer({ minimum: 2, maximum: 200 })),
+            }),
+            execute: async (_id, p) => {
+                const info = terminals.create(p.terminalId, p.cwd ?? cwd, p.cols ?? 120, p.rows ?? 40, cwd, p.terminalId);
+                if (!info)
+                    throw new Error(`创建终端失败：${p.terminalId}`);
+                return result(`终端已创建：${JSON.stringify(info)}`, info);
+            },
+        }),
+        defineTool({
+            name: "terminal_list",
+            label: "List terminals",
+            description: "List all persistent PTY terminals owned by this conversation.",
+            promptSnippet: "list persistent terminals",
+            parameters: Type.Object({}),
+            execute: async () => result(JSON.stringify(terminals.list()), terminals.list()),
+        }),
+        defineTool({
+            name: "terminal_close",
+            label: "Close terminal",
+            description: "Close a persistent PTY and terminate its process tree.",
+            parameters: Type.Object({ terminalId: Type.String() }),
+            execute: async (_id, p) => {
+                if (!terminals.has(p.terminalId))
+                    throw new Error(`终端不存在：${p.terminalId}`);
+                terminals.kill(p.terminalId);
+                return result(`终端已关闭：${p.terminalId}`);
+            },
+        }),
+        defineTool({
+            name: "terminal_input",
+            label: "Send terminal input",
+            description: "Send arbitrary text to a persistent PTY. Include newline when a command should be submitted.",
+            parameters: Type.Object({ terminalId: Type.String(), data: Type.String() }),
+            execute: async (_id, p) => {
+                failIf(terminals.inputChecked(p.terminalId, p.data));
+                return result(`已发送 ${p.data.length} 个字符到 ${p.terminalId}`);
+            },
+        }),
+        defineTool({
+            name: "terminal_key",
+            label: "Send terminal key",
+            description: "Send Enter, Tab, arrows, function keys, or Ctrl/Alt combinations to a persistent PTY.",
+            parameters: Type.Object({
+                terminalId: Type.String(),
+                key: Type.String({ description: "Enter, Tab, ArrowUp, c, etc." }),
+                modifiers: Type.Optional(Type.Object({
+                    ctrl: Type.Optional(Type.Boolean()),
+                    alt: Type.Optional(Type.Boolean()),
+                    shift: Type.Optional(Type.Boolean()),
+                })),
+            }),
+            execute: async (_id, p) => {
+                failIf(terminals.key(p.terminalId, p.key, p.modifiers));
+                return result(`已发送按键 ${p.key} 到 ${p.terminalId}`);
+            },
+        }),
+        defineTool({
+            name: "terminal_read",
+            label: "Read terminal output",
+            description: "Read incremental output from a persistent PTY. Keep the returned cursor and pass it on the next read; optionally wait for new output or process exit.",
+            parameters: Type.Object({
+                terminalId: Type.String(),
+                cursor: Type.Optional(Type.Integer({ minimum: 0 })),
+                maxBytes: Type.Optional(Type.Integer({ minimum: 1, maximum: 100000 })),
+                waitMs: Type.Optional(Type.Integer({ minimum: 0, maximum: 120000 })),
+            }),
+            execute: async (_id, p, signal) => {
+                const cursor = p.cursor ?? 0;
+                if (p.waitMs)
+                    await terminals.waitForOutput(p.terminalId, cursor, p.waitMs, signal);
+                const read = terminals.read(p.terminalId, cursor, p.maxBytes ?? 20000);
+                if (!read)
+                    throw new Error(`终端不存在：${p.terminalId}`);
+                return result(JSON.stringify(read), read);
+            },
+        }),
+    ];
+}
 /** First user text in a session, truncated for the conversation list. */
 function conversationTitle(session) {
     try {
@@ -1014,30 +1119,19 @@ export class ClientSession {
     // injects its feedback back into the main session to revise. All goal
     // mutation goes through setGoal/clearGoal so UI state stays consistent.
     // -----------------------------------------------------------------------
-    goal = {
-        goal: null,
+    /** Defaults remembered for newly-created conversations. Each conversation
+     * receives its own GoalStatus, so reviews can run concurrently. */
+    goalReviewPrefs = {
         reviewModel: null,
-        maxRounds: 0, // 0 = unlimited (keep revising until the goal passes)
+        maxRounds: 0,
         locked: true,
-        reviewing: false,
-        round: 0,
-        status: "",
-        verdict: "pending",
-        wizard: {
-            active: false,
-            draft: "",
-            model: null,
-            step: 0,
-            maxSteps: 6,
-            status: "",
-        },
     };
-    /** Guard: only one review may run at a time (agent_end fires per turn and
-     *  review is async). */
-    goalReviewing = false;
-    /** Guard: the goal wizard and the review loop are mutually exclusive — a
-     *  wizard in flight stops review triggers (and vice versa). */
-    goalWizardRunning = false;
+    /** Goal state exposed by the goal bar for the ACTIVE conversation. */
+    get goal() {
+        return this.conv.goal;
+    }
+    /** The browser has one dialog at a time, so wizard UI plumbing remains
+     * client-wide; review execution itself is per conversation. */
     /** Settings-panel state (system prompt + disabled skills/extensions). The
      *  resource-loader overrides in makeRuntimeFactory() read this at every
      *  reload(), so session.reload() applies changes to the running runtime. */
@@ -1059,6 +1153,8 @@ export class ClientSession {
     /** The wizard's AgentSession while it runs — lets clearGoal truly terminate it
      *  (abort the run), not just flip a flag. */
     wizardSession = null;
+    /** Conversation that owns the one browser wizard currently in flight. */
+    wizardOwnerId = null;
     /** True when the wizard was cancelled externally (✗ / clear_goal / timeout) —
      *  startGoalWizard reads this after the run to avoid setting a goal. */
     wizardCancelled = false;
@@ -1106,8 +1202,46 @@ export class ClientSession {
     get session() {
         return this.conv.session;
     }
-    /** PTY terminals for this client (killed when the last socket detaches). */
-    terminals = new TerminalManager((msg) => this.emit(msg));
+    /** PTYs are owned by individual conversations; this getter targets the active one
+     * for compatibility with the existing terminal-panel dispatch path. */
+    get terminals() {
+        return this.conv.terminals;
+    }
+    getTerminalManager(conversationId) {
+        return (conversationId ? this.convs.get(conversationId) : this.conv)?.terminals;
+    }
+    getTerminalCwd(conversationId) {
+        return (conversationId ? this.convs.get(conversationId) : this.conv)?.cwd ?? this.cwd;
+    }
+    makeTerminalManager(conversationId, cwd) {
+        return new TerminalManager((msg) => this.emitTerminal(conversationId, msg), cwd);
+    }
+    emitTerminal(conversationId, msg) {
+        // Background conversations keep collecting output in their own PTY buffer.
+        // Do not stream it into the active xterm; push the retained window on switch.
+        if (msg.type === "terminal_output" && conversationId !== this.activeId)
+            return;
+        if (msg.type === "terminal_output" || msg.type === "terminal_exit" || msg.type === "terminal_list") {
+            this.emit({ ...msg, conversationId });
+            return;
+        }
+        this.emit(msg);
+    }
+    pushTerminals(conversation = this.conv) {
+        this.emit({
+            type: "terminal_list",
+            conversationId: conversation.id,
+            terminals: conversation.terminals.list(),
+        });
+        for (const output of conversation.terminals.replay()) {
+            this.emit({
+                type: "terminal_output",
+                conversationId: conversation.id,
+                terminalId: output.terminalId,
+                data: output.data,
+            });
+        }
+    }
     /**
      * Vision-bridge transcript cache (batch hash → text). A re-sent / re-asked
      * prompt with the same images skips the vision API call entirely — editing
@@ -1181,11 +1315,15 @@ export class ClientSession {
         // Restore last-used goal/review preferences so model & rounds survive reload.
         const gPrefs = stateStore.getGoalPrefs(clientId);
         if (gPrefs) {
-            cs.goal.reviewModel = gPrefs.reviewModel;
-            cs.goal.maxRounds = gPrefs.maxRounds;
-            cs.goal.locked = gPrefs.locked;
+            cs.goalReviewPrefs = {
+                reviewModel: gPrefs.reviewModel,
+                maxRounds: gPrefs.maxRounds,
+                locked: gPrefs.locked,
+            };
         }
-        const runtime = await createAgentSessionRuntime(cs.makeRuntimeFactory(), {
+        const conversationId = cs.nextConversationId();
+        const terminals = cs.makeTerminalManager(conversationId, cwd);
+        const runtime = await createAgentSessionRuntime(cs.makeRuntimeFactory(terminals), {
             cwd,
             agentDir,
             // Resume the most recent session for this project — the SDK default
@@ -1196,7 +1334,7 @@ export class ClientSession {
         // First conversation = the resumed session; it also seeds the shared
         // ModelRuntime that every later conversation reuses.
         cs.sharedModelRuntime = runtime.services.modelRuntime;
-        const conv = cs.makeConversation(runtime);
+        const conv = cs.makeConversation(runtime, conversationId, terminals);
         cs.convs.set(conv.id, conv);
         cs.activeId = conv.id;
         for (const d of runtime.diagnostics) {
@@ -1216,7 +1354,7 @@ export class ClientSession {
      * (the model choice is client-wide), so later conversations reuse the
      * instance created with the first one.
      */
-    makeRuntimeFactory() {
+    makeRuntimeFactory(terminals) {
         return async ({ cwd: effectiveCwd, sessionManager }) => {
             const services = await createAgentSessionServices({
                 cwd: effectiveCwd,
@@ -1273,6 +1411,7 @@ export class ClientSession {
                     // abortBash() 只杀这些命令，agent run 与对话继续。
                     customTools: [
                         makeKillableBashTool(effectiveCwd, this.bashKills),
+                        ...makePersistentTerminalTools(terminals, effectiveCwd),
                     ],
                 })),
                 services,
@@ -1280,10 +1419,37 @@ export class ClientSession {
             };
         };
     }
+    /** Create independent goal state for one conversation. Preferences are
+     * client-wide defaults, while goal text/review progress is not shared. */
+    makeGoalStatus() {
+        return {
+            conversationId: null,
+            goal: null,
+            reviewModel: this.goalReviewPrefs.reviewModel,
+            maxRounds: this.goalReviewPrefs.maxRounds,
+            locked: this.goalReviewPrefs.locked,
+            reviewing: false,
+            round: 0,
+            status: "",
+            verdict: "pending",
+            wizard: {
+                active: false,
+                draft: "",
+                model: null,
+                step: 0,
+                maxSteps: 6,
+                status: "",
+            },
+        };
+    }
+    /** Allocate a stable conversation id before constructing its runtime/tools. */
+    nextConversationId() {
+        return `c${++this.convSeq}`;
+    }
     /** Wrap a fresh runtime as a new conversation record. */
-    makeConversation(runtime) {
+    makeConversation(runtime, id, terminals) {
         return {
-            id: `c${++this.convSeq}`,
+            id,
             title: conversationTitle(runtime.session),
             runtime,
             session: runtime.session,
@@ -1294,6 +1460,11 @@ export class ClientSession {
             listed: false,
             promptedSinceActive: false,
             lastActiveAt: Date.now(),
+            goal: this.makeGoalStatus(),
+            goalGeneration: 0,
+            goalReviewGeneration: 0,
+            wizardRunning: false,
+            terminals,
             msgIds: new Map(),
             nextMsgId: 1,
             userSeqByTs: new Map(),
@@ -1336,14 +1507,15 @@ export class ClientSession {
         // Reconnect: push the background-task list — it must survive reconnects
         // and outlive the conversation that started the tasks.
         this.emitBgServers();
+        // PTYs are conversation-owned and survive a socket reconnect.
+        this.pushTerminals();
     }
     detachSink(send) {
         this.sinks.delete(send);
-        // No sockets left for this client — kill its terminals so processes don't
-        // survive a closed tab / dropped connection.
+        // PTYs intentionally survive a socket drop: they are owned by the
+        // conversation and can be inspected after reconnecting. Only conversation
+        // disposal or server shutdown kills them.
         if (this.sinks.size === 0) {
-            this.terminals.killAll();
-            // No sockets → nobody to refresh; drop the dir watcher too.
             this.unwatchDir();
         }
     }
@@ -1510,7 +1682,7 @@ export class ClientSession {
             // (new chat + first message, completed turns, compaction, etc.).
             case "agent_end": {
                 this.scheduleSessionsRefresh();
-                const g = this.goal;
+                const g = conv.goal;
                 // Manual interrupt (Stop button / abort): the last assistant message
                 // carries stopReason "aborted". A half-finished run should NOT be
                 // reviewed (it would fail and inject a revision, only to be stopped
@@ -1521,12 +1693,14 @@ export class ClientSession {
                     return a.role === "assistant" && a.stopReason === "aborted";
                 });
                 if (aborted) {
-                    if (g.goal) {
-                        this.goal.goal = null;
-                        this.goal.reviewing = false;
-                        this.goal.verdict = "pending";
-                        this.goal.feedback = undefined;
-                        this.goal.status = "已手动停止，目标审查已中止";
+                    if (g.goal && g.conversationId === conv.id) {
+                        conv.goalGeneration += 1;
+                        g.conversationId = null;
+                        g.goal = null;
+                        g.reviewing = false;
+                        g.verdict = "pending";
+                        g.feedback = undefined;
+                        g.status = "已手动停止，目标审查已中止";
                         this.emitGoalStatus();
                         this.emit({
                             type: "notice",
@@ -1540,9 +1714,9 @@ export class ClientSession {
                 // active (and it belonged to the ACTIVE conversation) and we're not
                 // already mid-review, spawn the isolated reviewer.
                 if (g.goal &&
+                    g.conversationId === conv.id &&
                     !g.reviewing &&
-                    !this.goalWizardRunning &&
-                    conv.id === this.activeId &&
+                    !conv.wizardRunning &&
                     !this.disposed) {
                     void this.runGoalReview(conv);
                 }
@@ -2148,6 +2322,178 @@ export class ClientSession {
         });
         this.emit({ type: "models_config", providers: list });
     }
+    /** Numeric metadata value (NaN/string "unknown" → undefined). */
+    static numMeta(v) {
+        return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+    }
+    static boolMeta(v) {
+        return typeof v === "boolean" ? v : undefined;
+    }
+    static strArrMeta(v) {
+        return Array.isArray(v)
+            ? v.filter((x) => typeof x === "string")
+            : undefined;
+    }
+    /** Best-effort extraction of model metadata from an OpenAI-compatible
+     *  /models `data[]` item. Most endpoints only return `{ id }` — the extra
+     *  fields (context_window / max_model_len / modalities / supports_vision /
+     *  reasoning / display_name) come from vLLM and other extended
+     *  implementations, and are filled into the form when present. */
+    static parseOpenAiModel(m) {
+        const r = (m ?? {});
+        const id = typeof r.id === "string" ? r.id : "";
+        const name = (typeof r.name === "string" && r.name.trim() ? r.name : undefined) ??
+            (typeof r.display_name === "string" && r.display_name.trim()
+                ? r.display_name
+                : undefined);
+        const modalities = ClientSession.strArrMeta(r.modalities) ??
+            ClientSession.strArrMeta(r.input_modalities);
+        const vision = modalities?.includes("image") === true ||
+            ClientSession.boolMeta(r.supports_vision) === true ||
+            ClientSession.boolMeta(r.vision) === true ||
+            ClientSession.strArrMeta(r.input)?.includes("image") === true;
+        const reasoning = ClientSession.boolMeta(r.reasoning) === true ||
+            ClientSession.boolMeta(r.supports_reasoning) === true ||
+            modalities?.includes("reasoning") === true;
+        const contextWindow = ClientSession.numMeta(r.context_window) ??
+            ClientSession.numMeta(r.context_length) ??
+            ClientSession.numMeta(r.max_model_len) ??
+            ClientSession.numMeta(r.max_context_length);
+        const maxTokens = ClientSession.numMeta(r.max_tokens) ??
+            ClientSession.numMeta(r.max_output_tokens) ??
+            ClientSession.numMeta(r.max_completion_tokens);
+        return {
+            id,
+            ...(name ? { name } : {}),
+            ...(reasoning ? { reasoning: true } : {}),
+            ...(vision ? { input: ["text", "image"] } : {}),
+            ...(contextWindow ? { contextWindow } : {}),
+            ...(maxTokens ? { maxTokens } : {}),
+        };
+    }
+    /** google-generative-ai /models shape:
+     *  { models: [{ name: "models/gemini-flash", displayName, inputTokenLimit,
+     *               outputTokenLimit, supportedGenerationMethods }] } */
+    static parseGoogleModel(m) {
+        const r = (m ?? {});
+        const rawName = typeof r.name === "string" ? r.name : "";
+        const id = rawName.replace(/^models\//, "");
+        const displayName = typeof r.displayName === "string" ? r.displayName : undefined;
+        return {
+            id,
+            ...(displayName && displayName !== id ? { name: displayName } : {}),
+            ...(ClientSession.numMeta(r.inputTokenLimit)
+                ? { contextWindow: ClientSession.numMeta(r.inputTokenLimit) }
+                : {}),
+            ...(ClientSession.numMeta(r.outputTokenLimit)
+                ? { maxTokens: ClientSession.numMeta(r.outputTokenLimit) }
+                : {}),
+        };
+    }
+    /** Probe a custom provider's OpenAI-compatible /models endpoint (server-side
+     *  because the baseUrl is often a LAN/loopback host the browser can't reach
+     *  cross-origin) and return the advertised models. reqId is echoed back
+     *  in fetch_models_result so the UI can match concurrent requests. */
+    async fetchModelsList(reqId, baseUrl, apiKey, authHeader, api) {
+        const emitError = (error) => this.emit({ type: "fetch_models_result", reqId, ok: false, error });
+        const base = (baseUrl ?? "").trim().replace(/\/+$/, "");
+        if (!base)
+            return emitError("请先填写 baseUrl");
+        let url;
+        try {
+            url = new URL(base);
+        }
+        catch {
+            return emitError(`baseUrl 无效：${base}`);
+        }
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            return emitError("baseUrl 仅支持 http/https");
+        }
+        const headers = {};
+        // Per-api auth conventions (mirror pi's built-in provider configs):
+        //   openai-*:      Authorization: Bearer <key>
+        //   anthropic:     x-api-key + anthropic-version
+        //   google:        x-goog-api-key
+        // authHeader=false → no auth header at all (custom gateways).
+        if (apiKey?.trim() && authHeader !== false) {
+            const key = apiKey.trim();
+            if (api === "anthropic-messages") {
+                headers["x-api-key"] = key;
+                headers["anthropic-version"] = "2023-06-01";
+            }
+            else if (api === "google-generative-ai") {
+                headers["x-goog-api-key"] = key;
+            }
+            else {
+                headers["Authorization"] = `Bearer ${key}`;
+            }
+        }
+        const tryFetch = async (u) => {
+            const ac = new AbortController();
+            const timer = setTimeout(() => ac.abort(), 15000);
+            try {
+                return await fetch(u, { headers, signal: ac.signal });
+            }
+            catch (err) {
+                if (err.name === "AbortError") {
+                    emitError("请求超时（15 秒）");
+                }
+                else {
+                    emitError(`请求失败：${err.message}`);
+                }
+                return null;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        };
+        let res = await tryFetch(`${base}/models`);
+        // BaseUrls that omit the /v1 prefix (e.g. https://api.openai.com) 404 on
+        // the bare path — retry under /v1.
+        if (res && res.status === 404 && !/\/v\d+[a-z-]*$/.test(base)) {
+            res = await tryFetch(`${base}/v1/models`);
+        }
+        if (!res)
+            return;
+        if (!res.ok) {
+            let detail = "";
+            try {
+                detail = (await res.text()).slice(0, 200);
+            }
+            catch {
+                // response body already consumed / not text — ignore
+            }
+            return emitError(`接口返回 HTTP ${res.status}${detail ? `：${detail}` : ""}`);
+        }
+        let models = [];
+        try {
+            const json = (await res.json());
+            const data = Array.isArray(json.data) ? json.data : null;
+            if (data) {
+                // OpenAI-compatible: { data: [{ id, context_window, modalities, … }] }
+                models = data
+                    .map((m) => ClientSession.parseOpenAiModel(m))
+                    .filter((m) => m.id);
+            }
+            else if (Array.isArray(json.models)) {
+                // Google: { models: [{ name: "models/…", displayName, … }] }
+                models = json.models
+                    .map((m) => ClientSession.parseGoogleModel(m))
+                    .filter((m) => m.id);
+            }
+        }
+        catch {
+            return emitError("响应不是有效的 JSON");
+        }
+        // Dedupe by id (keep the first, most complete entry) and sort by id.
+        const seen = new Set();
+        models = models
+            .filter((m) => (seen.has(m.id) ? false : (seen.add(m.id), true)))
+            .sort((a, b) => a.id.localeCompare(b.id));
+        if (models.length === 0)
+            return emitError("接口未返回任何模型");
+        this.emit({ type: "fetch_models_result", reqId, ok: true, models });
+    }
     /** Upsert one provider into models.json and hot-reload the model runtime. */
     async saveModelConfig(providerId, config) {
         const pid = providerId.trim();
@@ -2531,6 +2877,7 @@ export class ClientSession {
      *  settings change. */
     pushSettings() {
         const disabledSkills = new Set(this.settings.disabledSkills);
+        const reviewDisabledSkills = new Set(this.settings.reviewDisabledSkills);
         const disabledExts = new Set(this.settings.disabledExtensions);
         try {
             // Refresh the cache with the CURRENTLY loaded set (post-filter).
@@ -2577,6 +2924,9 @@ export class ClientSession {
         const skills = [...this.knownSkills.values()]
             .map((s) => ({ ...s, enabled: !disabledSkills.has(s.name) }))
             .sort((a, b) => a.name.localeCompare(b.name));
+        const reviewSkills = [...this.knownSkills.values()]
+            .map((s) => ({ ...s, enabled: !reviewDisabledSkills.has(s.name) }))
+            .sort((a, b) => a.name.localeCompare(b.name));
         const extensions = [...this.knownExtensions.values()]
             .map((e) => ({ ...e, enabled: !disabledExts.has(e.id) }))
             .sort((a, b) => a.name.localeCompare(b.name));
@@ -2589,6 +2939,8 @@ export class ClientSession {
                 visionBridgeModel: this.settings.visionBridgeModel,
                 visionBridgePromptMode: this.settings.visionBridgePromptMode,
                 visionBridgePrompt: this.settings.visionBridgePrompt,
+                reviewPrompt: this.settings.reviewPrompt,
+                reviewDisabledSkills: [...this.settings.reviewDisabledSkills],
                 // The built-in prompts, so the replace-mode editors can prefill the
                 // text they would otherwise replace (empty until the resource-loader
                 // has run once for the system prompt).
@@ -2598,6 +2950,7 @@ export class ClientSession {
                 disabledSkills: [...this.settings.disabledSkills],
                 disabledExtensions: [...this.settings.disabledExtensions],
                 skills,
+                reviewSkills,
                 extensions,
                 presets: this.presets.map((p) => ({ ...p })),
             },
@@ -2646,6 +2999,12 @@ export class ClientSession {
         if (partial.visionBridgePrompt !== undefined) {
             this.settings.visionBridgePrompt = partial.visionBridgePrompt;
         }
+        if (partial.reviewPrompt !== undefined) {
+            this.settings.reviewPrompt = partial.reviewPrompt;
+        }
+        if (partial.reviewDisabledSkills !== undefined) {
+            this.settings.reviewDisabledSkills = partial.reviewDisabledSkills;
+        }
         this.stateStore.saveSettings(this.clientId, this.settings);
         this.pushSettings();
         if (needsReload)
@@ -2664,6 +3023,8 @@ export class ClientSession {
             customSystemPrompt: this.settings.customSystemPrompt,
             disabledSkills: [...this.settings.disabledSkills],
             disabledExtensions: [...this.settings.disabledExtensions],
+            reviewPrompt: this.settings.reviewPrompt,
+            reviewDisabledSkills: [...this.settings.reviewDisabledSkills],
         };
         const existing = this.presets.findIndex((p) => p.name === n);
         if (existing >= 0)
@@ -2685,6 +3046,10 @@ export class ClientSession {
             customSystemPrompt: p.customSystemPrompt,
             disabledSkills: [...p.disabledSkills],
             disabledExtensions: [...p.disabledExtensions],
+            reviewPrompt: p.reviewPrompt ?? this.settings.reviewPrompt,
+            reviewDisabledSkills: [
+                ...(p.reviewDisabledSkills ?? this.settings.reviewDisabledSkills),
+            ],
             // Presets don't capture vision-bridge prefs — keep the current ones.
             visionBridgeEnabled: this.settings.visionBridgeEnabled,
             visionBridgeModel: this.settings.visionBridgeModel,
@@ -3685,7 +4050,7 @@ ${transcript}
             this.clearAllToolWatchdogs(conv);
             conv.toolStartTimes.clear();
             await conv.runtime.dispose();
-            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(), {
+            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(conv.terminals), {
                 cwd: conv.cwd,
                 agentDir: this.agentDir,
                 sessionManager: SessionManager.continueRecent(conv.cwd),
@@ -3715,7 +4080,7 @@ ${transcript}
         // this branch normally can't exist — kept as a safety net).
         const isBlank = (c) => {
             try {
-                return c.session.getSessionStats().totalMessages === 0;
+                return c.session.getSessionStats().totalMessages === 0 && c.terminals.list().length === 0;
             }
             catch {
                 // session being replaced — treat as used so we don't switch onto it
@@ -3752,18 +4117,22 @@ ${transcript}
         // conversation stays valid during the (async) runtime creation.
         const displaced = this.displaceActive();
         try {
-            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(), {
+            const conversationId = this.nextConversationId();
+            const terminals = this.makeTerminalManager(conversationId, this.cwd);
+            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals), {
                 cwd: this.cwd,
                 agentDir: this.agentDir,
                 sessionManager: SessionManager.create(this.cwd),
             });
-            const conv = this.makeConversation(runtime);
+            const conv = this.makeConversation(runtime, conversationId, terminals);
             this.convs.set(conv.id, conv);
             this.activeId = conv.id;
             if (displaced)
                 this.removeConversation(displaced.id);
             await this.bindSession();
             this.emitConversations();
+            this.emitGoalStatus();
+            this.pushTerminals();
             // The new runtime re-discovered skills/templates — refresh the catalog
             // so the picker stops showing the previous runtime's list.
             void this.pushSlashCommands();
@@ -3783,16 +4152,30 @@ ${transcript}
      *
      * - still streaming → it becomes a background run: ensure it is listed;
      * - idle + listed + continued → keep it (the user did continue it);
+     * - any retained terminal state → keep it listed until the terminals are closed;
      * - idle + listed + opened-but-not-continued, or never listed at all → the
      *   caller must drop it (returns it so removal happens only after the
      *   active conversation has been switched away).
      */
     displaceActive() {
         const conv = this.conv;
+        // An isolated reviewer can keep working while the main session is idle;
+        // retain that conversation so its review is not disposed when the user
+        // switches away without sending another prompt.
+        if (conv.goal.reviewing || conv.wizardRunning) {
+            conv.listed = true;
+            return null;
+        }
         if (conv.session.isStreaming) {
             conv.listed = true;
             return null;
         }
+        // Terminal state is a reason to keep an otherwise idle conversation alive:
+        // switching chats must not kill a PTY the user or agent may still need.
+        if (conv.terminals.list().length > 0) {
+            conv.listed = true;
+            return null;
+        }
         if (conv.listed && conv.promptedSinceActive)
             return null;
         return conv;
@@ -3806,6 +4189,7 @@ ${transcript}
             return;
         this.convs.delete(id);
         this.clearAllToolWatchdogs(conv);
+        conv.terminals.killAll();
         conv.unsubscribe?.();
         conv.unsubscribe = undefined;
         void conv.runtime.dispose().catch(() => { });
@@ -3825,6 +4209,8 @@ ${transcript}
         this.conv.lastActiveAt = Date.now();
         this.webUi.refresh();
         this.emitConversations();
+        this.emitGoalStatus();
+        this.pushTerminals();
         // The switched-to conversation has its own runtime (own resource cache).
         void this.pushSlashCommands();
         this.flushSnapshot();
@@ -4399,12 +4785,14 @@ ${transcript}
             }
             else {
                 // First visit to this project: resume its most recent session.
-                const newRuntime = await createAgentSessionRuntime(this.makeRuntimeFactory(), {
+                const conversationId = this.nextConversationId();
+                const terminals = this.makeTerminalManager(conversationId, abs);
+                const newRuntime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals), {
                     cwd: abs,
                     agentDir: this.agentDir,
                     sessionManager: SessionManager.continueRecent(abs),
                 });
-                const conv = this.makeConversation(newRuntime);
+                const conv = this.makeConversation(newRuntime, conversationId, terminals);
                 this.convs.set(conv.id, conv);
                 this.activeId = conv.id;
                 if (displaced)
@@ -4416,6 +4804,7 @@ ${transcript}
                 }
                 await this.bindSession();
             }
+            this.pushTerminals();
             this.conv.promptedSinceActive = false;
             this.conv.lastActiveAt = Date.now();
             this.cwd = abs;
@@ -4424,6 +4813,7 @@ ${transcript}
             void this.pushProjects();
             this.webUi.refresh();
             this.emitConversations();
+            this.emitGoalStatus();
             // Skills / prompt templates are project-bound — refresh the catalog.
             void this.pushSlashCommands();
             this.emit({
@@ -4470,9 +4860,17 @@ ${transcript}
     // ---------------------------------------------------------------------------
     // Goal / review
     // ---------------------------------------------------------------------------
-    /** Push the current goal status to the client (the goal bar UI). */
+    /** Push the active conversation's goal status to the client (the goal bar
+     * UI). Conversations without an active goal reflect the client's remembered
+     * defaults; an existing goal keeps its own review settings. */
     emitGoalStatus() {
-        this.emit({ type: "goal_status", status: { ...this.goal } });
+        const goal = this.goal;
+        if (!goal.goal && !goal.reviewing && !goal.wizard.active) {
+            goal.reviewModel = this.goalReviewPrefs.reviewModel;
+            goal.maxRounds = this.goalReviewPrefs.maxRounds;
+            goal.locked = this.goalReviewPrefs.locked;
+        }
+        this.emit({ type: "goal_status", status: { ...goal } });
     }
     /**
      * Set (or clear) the active goal. `goal === ""` clears it. The goal is
@@ -4485,6 +4883,13 @@ ${transcript}
             await this.clearGoal();
             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
+        // from consuming the previous conversation's goal.
+        const goalConversationId = this.activeId;
+        this.conv.goalGeneration += 1;
+        this.goal.reviewing = false;
+        this.goal.conversationId = goalConversationId;
         this.goal.goal = text;
         // Model & rounds preference semantics ("全局记忆"):
         //  - reviewModel undefined → keep the remembered choice; empty → main model.
@@ -4497,6 +4902,11 @@ ${transcript}
         }
         if (opts?.locked !== undefined)
             this.goal.locked = opts.locked;
+        this.goalReviewPrefs = {
+            reviewModel: this.goal.reviewModel,
+            maxRounds: this.goal.maxRounds,
+            locked: this.goal.locked,
+        };
         // Persist the chosen preferences so they survive reload.
         this.stateStore.saveGoalPrefs(this.clientId, {
             reviewModel: this.goal.reviewModel,
@@ -4537,7 +4947,7 @@ ${transcript}
      * in-memory session, so its model choice is its own) that questions the user
      * via `goal_ask` (multiple-choice + free-text, bridged to the browser through
      * the existing select/input dialog), converging on a goal, then auto-sets it.
-     * Mutually exclusive with the review loop.
+     * Mutually exclusive with the review loop of the same conversation.
      */
     async startGoalWizard(text, opts) {
         if (this.quiesceBlocked())
@@ -4545,7 +4955,12 @@ ${transcript}
         const draft = (text ?? "").trim();
         if (!draft)
             return;
-        if (this.goalWizardRunning) {
+        // The wizard and its progress cards belong to the conversation that
+        // launched it. If the user switches away, do not later set a goal on the
+        // new active conversation while the wizard is still finishing.
+        const wizardConversationId = this.activeId;
+        const wizardConversation = this.conv;
+        if (wizardConversation.wizardRunning || this.wizardOwnerId !== null) {
             this.emit({
                 type: "notice",
                 level: "warning",
@@ -4553,7 +4968,7 @@ ${transcript}
             });
             return;
         }
-        if (this.goalReviewing) {
+        if (wizardConversation.goal.reviewing) {
             this.emit({
                 type: "notice",
                 level: "warning",
@@ -4565,25 +4980,37 @@ ${transcript}
         // the idle- and total-timeouts are the only guards. maxSteps is purely a
         // soft UI indicator, not a hard stop.
         const maxSteps = 20;
-        this.goalWizardRunning = true;
+        wizardConversation.wizardRunning = true;
+        this.wizardOwnerId = wizardConversationId;
         this.wizardCancelled = false;
         this.wizardAbort = new AbortController();
         this.wizardSession = null;
-        this.goal.wizard.active = true;
-        this.goal.wizard.draft = draft;
-        this.goal.wizard.model = opts?.wizardModel ?? null;
+        wizardConversation.goal.wizard.active = true;
+        wizardConversation.goal.wizard.draft = draft;
+        wizardConversation.goal.wizard.model = opts?.wizardModel ?? null;
         // Remember the model choice (and persist rounds/lock) — global memory.
         if (opts?.wizardModel !== undefined && opts.wizardModel !== null)
-            this.goal.reviewModel = opts.wizardModel || null;
+            wizardConversation.goal.reviewModel = opts.wizardModel || null;
+        if (typeof opts?.maxRounds === "number") {
+            const mr = Math.round(opts.maxRounds);
+            wizardConversation.goal.maxRounds = mr >= 1 ? Math.min(mr, 50) : 0;
+        }
+        if (opts?.locked !== undefined)
+            wizardConversation.goal.locked = opts.locked;
+        this.goalReviewPrefs = {
+            reviewModel: wizardConversation.goal.reviewModel,
+            maxRounds: wizardConversation.goal.maxRounds,
+            locked: wizardConversation.goal.locked,
+        };
         this.stateStore.saveGoalPrefs(this.clientId, {
-            reviewModel: this.goal.reviewModel,
-            maxRounds: this.goal.maxRounds,
-            locked: this.goal.locked,
+            reviewModel: wizardConversation.goal.reviewModel,
+            maxRounds: wizardConversation.goal.maxRounds,
+            locked: wizardConversation.goal.locked,
         });
-        this.goal.wizard.step = 0;
-        this.goal.wizard.maxSteps = maxSteps;
-        this.goal.wizard.status = "调研中…";
-        this.goal.status = "目标调研中…";
+        wizardConversation.goal.wizard.step = 0;
+        wizardConversation.goal.wizard.maxSteps = maxSteps;
+        wizardConversation.goal.wizard.status = "调研中…";
+        wizardConversation.goal.status = "目标调研中…";
         this.emitGoalStatus();
         // Idle-timeout: cancel the wizard if no question is answered within the
         // window (a stale dialog with no user response must not run forever). A
@@ -4623,21 +5050,14 @@ ${transcript}
             text: `🔍 正在围绕需求展开调研：${draft.slice(0, 60)}${draft.length > 60 ? "…" : ""}`,
         });
         // The main conversation to show wizard progress cards in.
-        let mainSession = this.session;
-        try {
-            const conv = this.conv;
-            mainSession = conv.session;
-        }
-        catch {
-            // no active conversation yet
-        }
+        const mainSession = wizardConversation.session;
         let refinedGoal = "";
         try {
             const wmSpec = opts?.wizardModel
                 ? this.resolveReviewModel(opts.wizardModel)
                 : null; // reuse the honest "provider/id" parser
             const services = await createAgentSessionServices({
-                cwd: this.cwd,
+                cwd: wizardConversation.cwd,
                 agentDir: this.agentDir,
                 modelRuntime: await ModelRuntime.create({
                     authPath: join(this.agentDir, "auth.json"),
@@ -4683,8 +5103,8 @@ ${transcript}
                     }
                     // Show the question in the main flow BEFORE blocking on the dialog, so
                     // the user sees the wizard working even before answering.
-                    this.goal.wizard.step = qStep;
-                    this.goal.wizard.status = `调研中：请回答第 ${qStep} 题`;
+                    wizardConversation.goal.wizard.step = qStep;
+                    wizardConversation.goal.wizard.status = `调研中：请回答第 ${qStep} 题`;
                     this.emitGoalStatus();
                     try {
                         armIdle();
@@ -4790,10 +5210,12 @@ ${transcript}
         finally {
             clearIdle();
             clearTimeout(totalTimer);
-            this.goalWizardRunning = false;
-            this.goal.wizard.active = false;
-            this.goal.wizard.step = 0;
-            this.goal.wizard.status = "";
+            wizardConversation.wizardRunning = false;
+            if (this.wizardOwnerId === wizardConversationId)
+                this.wizardOwnerId = null;
+            wizardConversation.goal.wizard.active = false;
+            wizardConversation.goal.wizard.step = 0;
+            wizardConversation.goal.wizard.status = "";
             this.wizardSession = null;
             this.emitGoalStatus();
         }
@@ -4815,19 +5237,27 @@ ${transcript}
             });
             return;
         }
+        if (this.activeId !== wizardConversationId) {
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: "已切换对话，目标调研结果已丢弃",
+            });
+            return;
+        }
         // 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;
         // without it the review is single-shot).
         const wantLocked = opts?.locked === undefined ? true : opts.locked;
         await this.setGoal(refinedGoal, {
-            reviewModel: this.goal.reviewModel ?? undefined,
+            reviewModel: wizardConversation.goal.reviewModel ?? undefined,
             maxRounds: opts?.maxRounds,
             locked: wantLocked,
             // The wizard kicks off generation itself below — avoid a double kick.
             autoStart: false,
         });
-        const g2 = this.goal;
+        const g2 = wizardConversation.goal;
         this.wizardCancelled = false;
         this.wizardAbort = null;
         this.emit({
@@ -4857,6 +5287,11 @@ ${transcript}
         }
         if (opts?.locked !== undefined)
             this.goal.locked = opts.locked;
+        this.goalReviewPrefs = {
+            reviewModel: this.goal.reviewModel,
+            maxRounds: this.goal.maxRounds,
+            locked: this.goal.locked,
+        };
         this.stateStore.saveGoalPrefs(this.clientId, {
             reviewModel: this.goal.reviewModel,
             maxRounds: this.goal.maxRounds,
@@ -4867,6 +5302,9 @@ ${transcript}
     /** Clear the active goal (cancels the review loop AND aborts a running
      *  goal wizard — truly terminating its in-flight dialog + agent run). */
     async clearGoal() {
+        this.conv.goalGeneration += 1;
+        this.goal.reviewing = false;
+        this.goal.conversationId = null;
         this.goal.goal = null;
         this.goal.reviewing = false;
         this.goal.verdict = "pending";
@@ -4876,7 +5314,7 @@ ${transcript}
         this.goal.status = "";
         this.emitGoalStatus();
         // Abort a running wizard for real (✗ in the goal bar while scoping).
-        if (this.goalWizardRunning || this.wizardAbort || this.wizardSession) {
+        if (this.wizardOwnerId === this.activeId) {
             this.wizardCancelled = true;
             this.webUi.cancelPendingDialogs();
             this.wizardAbort?.abort();
@@ -4902,7 +5340,7 @@ ${transcript}
      * The whitelisted reviewer plan — tell the reviewer what to decide and how
      * to report, regardless of which model it runs on.
      */
-    reviewerPrompt(goal, round, maxRounds, output, gitDiff) {
+    reviewerPrompt(goal, round, maxRounds, output, gitDiff, customPrompt = "") {
         return [
             `You are a strict, independent goal-reviewer. Your ONLY job is to judge whether the agent's work fully satisfies the stated goal, by checking the agent's final output and, when present, its git diff.`, // eslint-disable-line max-len
             ``,
@@ -4916,6 +5354,9 @@ ${transcript}
             gitDiff.length > 0 ? gitDiff : "(no staged/committed changes detected)", // eslint-disable-line max-len
             ``,
             `This is review round ${round}${maxRounds > 0 ? ` of up to ${maxRounds}` : " (no round cap — keep revising until it passes)"}.`, // eslint-disable-line max-len
+            ...(customPrompt.trim()
+                ? [``, `# Additional reviewer instructions`, customPrompt.trim()]
+                : []),
             ``,
             `Decide: does the work satisfy the goal? If yes, respond with ONLY a JSON object with this exact shape (no markdown fences, no extra text):`, // eslint-disable-line max-len
             `{"verdict":"pass","feedback":"<one short sentence: what was satisfied>"}`, // eslint-disable-line max-len
@@ -4940,10 +5381,11 @@ ${transcript}
             // Non-fatal
         }
     }
-    /** Run a git diff (unstaged + staged) in the workspace, or "" when not a repo. */
-    async gitDiff() {
+    /** Run a git diff (unstaged + staged) in a conversation's workspace, or
+     * "" when not a repo. */
+    async gitDiff(cwd) {
         try {
-            const { code, out } = await this.runAsync("git", ["diff", "HEAD"], 10_000, this.cwd);
+            const { code, out } = await this.runAsync("git", ["diff", "HEAD"], 10_000, cwd);
             if (code !== 0)
                 return "";
             return out.slice(0, 60_000);
@@ -4960,33 +5402,59 @@ ${transcript}
      *   - fail  → inject the feedback as a user message into the main session
      *             to steer a revision; the next agent_end re-reviews with the
      *             same round budget.
-     * Guarded so it never runs two reviews concurrently.
+     * Guarded per conversation so separate conversations can review concurrently.
      */
+    isCurrentGoalReview(conv, goalGeneration, reviewGeneration) {
+        return (!this.disposed &&
+            this.convs.get(conv.id) === conv &&
+            conv.goal.conversationId === conv.id &&
+            conv.goalGeneration === goalGeneration &&
+            conv.goalReviewGeneration === reviewGeneration &&
+            !!conv.goal.goal);
+    }
+    /** Drop the result of a review that became stale while it was awaiting the
+     * reviewer model (most commonly because the user switched conversations). */
+    discardStaleGoalReview(conv, goalGeneration, reviewGeneration) {
+        if (conv.goalReviewGeneration !== reviewGeneration)
+            return;
+        if (conv.goalGeneration === goalGeneration &&
+            conv.goal.conversationId === conv.id) {
+            conv.goal.reviewing = false;
+            conv.goal.status = "审查已中止，目标已更新或取消";
+            this.emitGoalStatus();
+        }
+    }
     async runGoalReview(conv) {
-        // The review is bound to the conversation that just ran — but the user may
-        // have switched to another conversation meanwhile. Reviews only make sense
-        // for the conversation that generated output, so track it locally.
+        // The review is bound to the conversation that just ran. Capture both the
+        // owner and a generation so a later switch/set/clear cannot let an old,
+        // asynchronous reviewer mutate the new conversation's goal state.
         const mainConv = this.convs.get(conv.id) ?? conv;
         const mainSession = mainConv.session;
-        const g = this.goal;
+        const g = conv.goal;
         if (!g.goal ||
-            this.goalReviewing ||
-            this.goalWizardRunning ||
+            g.conversationId !== conv.id ||
+            g.reviewing ||
+            conv.wizardRunning ||
             this.disposed)
             return;
+        const goalGeneration = conv.goalGeneration;
+        const reviewGeneration = ++conv.goalReviewGeneration;
         // Narrowed copy — TS control-flow can't narrow `g.goal` (a mutable shared
         // object field) through the entire async body, so capture it here.
         const goalText = g.goal;
+        // Capture review-only settings for this run. Changing settings while a
+        // review is in flight affects the next review, never this one.
+        const reviewPrompt = this.settings.reviewPrompt;
+        const reviewDisabledSkills = new Set(this.settings.reviewDisabledSkills);
         // Cap rounds: single-shot (locked=false) always exactly one review.
         // For locked goals, maxRounds 0 = unlimited (keep revising until pass).
         const budget = g.locked ? (g.maxRounds > 0 ? g.maxRounds : Infinity) : 1;
         if (g.locked && g.maxRounds > 0 && g.round >= budget) {
-            this.goal.status = `已达最大轮数（${budget}），停止审查`;
-            this.goal.reviewing = false;
+            g.status = `已达最大轮数（${budget}），停止审查`;
+            g.reviewing = false;
             this.emitGoalStatus();
             return;
         }
-        this.goalReviewing = true;
         g.reviewing = true;
         g.round += 1;
         g.verdict = "pending";
@@ -5001,14 +5469,26 @@ ${transcript}
         catch {
             finalText = "";
         }
-        const diff = await this.gitDiff();
+        const diff = await this.gitDiff(mainConv.cwd);
+        if (!this.isCurrentGoalReview(conv, goalGeneration, reviewGeneration)) {
+            this.discardStaleGoalReview(conv, goalGeneration, reviewGeneration);
+            return;
+        }
         let reviewerVerdict = "fail";
         let reviewerFeedback = "（审查无法完成）";
         try {
             const rmSpec = this.resolveReviewModel(g.reviewModel);
             const services = await createAgentSessionServices({
-                cwd: this.cwd,
+                cwd: mainConv.cwd,
                 agentDir: this.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({
@@ -5030,12 +5510,12 @@ ${transcript}
             }
             const srv = await createAgentSessionFromServices({
                 services,
-                sessionManager: SessionManager.inMemory(this.cwd),
+                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));
+            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)"[^}]*\}/);
@@ -5055,7 +5535,13 @@ ${transcript}
             reviewerVerdict = "fail";
             reviewerFeedback = `审查过程中出错：${err.message}`;
         }
-        this.goalReviewing = false;
+        // 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
+        // into the old session after that point.
+        if (!this.isCurrentGoalReview(conv, goalGeneration, reviewGeneration)) {
+            this.discardStaleGoalReview(conv, goalGeneration, reviewGeneration);
+            return;
+        }
         g.reviewing = false;
         g.verdict = reviewerVerdict;
         g.feedback = reviewerFeedback;
@@ -5069,6 +5555,7 @@ ${transcript}
         if (verdict === "pass") {
             g.status = "✅ 已通过目标审查";
             this.emit({ type: "notice", level: "info", text: "✅ 目标已通过审查" });
+            g.conversationId = null;
             g.goal = null; // a passed goal is done and cleared
             this.emitGoalStatus();
             // Pass = the review result goes straight into the conversation as an
@@ -5124,6 +5611,7 @@ ${transcript}
             // Best-effort.
         }
         this.emit({ type: "notice", level: "warning", text: "目标未通过审查（已达最大轮数）" });
+        g.conversationId = null;
         g.goal = null; // loop exhausted — clear the active goal
         this.emitGoalStatus();
         this.flushSnapshot();
@@ -5199,7 +5687,8 @@ ${transcript}
     }
     async dispose() {
         this.disposed = true;
-        this.terminals.killAll();
+        for (const conv of this.convs.values())
+            conv.terminals.killAll();
         if (this.snapshotTimer) {
             clearTimeout(this.snapshotTimer);
             this.snapshotTimer = null;