pi-web-ui 0.85.0 → 0.86.2

package/dist/server/agent-service.js

@@ -17,13 +17,13 @@ import "./patch-remote-catalog.js";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, rmSync, statSync, mkdirSync, watch } from "node:fs";
+import { appendFileSync, existsSync, readFileSync, rmSync, statSync, mkdirSync, watch, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashToolDefinition, createLocalBashOperations, getAgentDir, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { BgServerTracker } from "./bg-servers.js";
-import { checkAll as checkAllUpdates, collectTargets, compareVersions as compareSemver, } from "./update-check.js";
+import { checkAll as checkAllUpdates, collectTargets, compareVersions as compareSemver, resolveNpmRegistry, } from "./update-check.js";
 import { hasActiveSubagentRun, hasPendingWaitSubscription, shouldRetainActive } from "./wait-subscription-scan.js";
 import { removeFirstOccurrence } from "./queue-utils.js";
 import { syncPluginToolsIntoSession } from "./plugins.js";
@@ -771,6 +771,9 @@ export class ClientSession {
      *  (server draining — new work rejected). Default false for direct use. */
     isQuiesced = () => false;
     cwd;
+    /** 当前项目的额外工作区根（宿主侧多根，见 protocol 的 set_workspace_roots）——
+     *  按 cwd 存在 client-state 里，这里只存一份内存缓存给快照热路径读。 */
+    roots = [];
     /** pi config dir (auth/models/skills). */
     agentDir;
     /** Persisted per-client UI state (last workspace + recent projects). */
@@ -1396,6 +1399,7 @@ export class ClientSession {
         this.cwd = cwd;
         this.agentDir = agentDir;
         this.stateStore = stateStore;
+        this.roots = stateStore.getWorkspaceRoots(clientId, cwd);
         this.subagentTemplates = new SubagentTemplatesStore(join(stateStore.dataDir, "subagent-templates.json"));
         this.markerSvc = new MarkerService({
             clientId,
@@ -1485,7 +1489,7 @@ export class ClientSession {
         // the list is non-empty). unref: must not keep the process alive.
         this.bg.start();
     }
-    static async create(clientId, cwd, stateStore) {
+    static async create(clientId, cwd, stateStore, opts) {
         const agentDir = process.env.PI_CODING_AGENT_DIR ?? getAgentDir();
         const cs = new ClientSession(clientId, cwd, agentDir, stateStore);
         const conversationId = cs.nextConversationId();
@@ -1496,7 +1500,8 @@ export class ClientSession {
             // Resume the most recent session for this project — the SDK default
             // per-project dir (<agentDir>/sessions/--<cwd>--/, shared with the
             // pi CLI/TUI) — or start a fresh one on first visit.
-            sessionManager: SessionManager.continueRecent(cwd),
+            // issue #145: opts.blank = 跳过恢复（最近那条在别处跑着），直接空白新对话。
+            sessionManager: opts?.blank ? SessionManager.create(cwd) : SessionManager.continueRecent(cwd),
         });
         // First conversation = the resumed session; it also seeds the shared
         // ModelRuntime that every later conversation reuses.
@@ -1514,6 +1519,15 @@ export class ClientSession {
                 });
             }
         }
+        // issue #145：因别处正在跑而跳过恢复 —— 首帧即被告之（pendingNotices 随 attachSink 下发）。
+        if (opts?.blank && opts?.blankTitle) {
+            cs.pendingNotices.push({
+                type: "notice",
+                level: "info",
+                text: `该项目最近的对话「${opts.blankTitle}」正在另一处运行，为你停在了新对话 —— 直接打开会造出第二个写者。左栏「运行的对话」里能看到它（标着“另一处”），等它跑完再打开。`,
+                textEn: `The most recent conversation ("${opts.blankTitle}") is running in another window, so you landed on a new chat instead — opening it here would create a second writer. It is listed under Running chats (tagged "Elsewhere"); open it after it finishes.`,
+            });
+        }
         await cs.bindSession();
         await cs.restoreProjectProviderKeysForCwd(cwd);
         await cs.restoreProjectModelForCwd(cwd);
@@ -2151,13 +2165,29 @@ export class ClientSession {
             // 手动 /compact 或阈值/溢出自动压缩开始——常驻进度条（快照 compaction
             // 字段），而不是一次性 toast（toast 几秒就消失，而摘要生成可能持续
             // 数十秒，用户会以为「没反应」）。立即 flush 让进度条第一时间出现。
+            // 服务端重启会杀死压缩中的 LLM 调用且 compaction_end 永远不会到：
+            // 把带时间戳的待处理标记写进会话文件（与 SDK 条目同格式、可追加），
+            // 重启后打开该会话时检测到它即报「上次压缩被中断，可重试」，而不是
+            // 静默丢失。标记在 compaction_end 到达时删除（正常完成不留痕）。
             case "compaction_start": {
                 conv.compactionState = { reason: event.reason, startedAt: Date.now() };
                 conv.lastCompactionTokens = null;
+                this.markCompactionPending(conv);
                 this.flushSnapshot();
                 break;
             }
             case "compaction_end": {
+                this.clearCompactionPending(conv, event.errorMessage
+                    ? { status: "failed", error: event.errorMessage }
+                    : event.aborted
+                        ? { status: "cancelled" }
+                        : event.result
+                            ? {
+                                status: "completed",
+                                tokensBefore: event.result.tokensBefore,
+                                tokensAfter: event.result.estimatedTokensAfter ?? event.result.tokensBefore,
+                            }
+                            : undefined);
                 conv.compactionState = null;
                 if (event.errorMessage) {
                     this.emit({
@@ -2555,6 +2585,8 @@ export class ClientSession {
         return {
             clientId: this.clientId,
             cwd: this.cwd,
+            // 判重：直接读缓存字段，不在快照热路径上重读 client-state。
+            workspaceRoots: this.roots,
             sessionId: this.session.sessionId,
             sessionFile: this.session.sessionFile,
             conversationId: this.activeId,
@@ -2936,19 +2968,38 @@ export class ClientSession {
     }
     /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
     onQuit = undefined;
-    /** 本客户端成功切换工作区（set_cwd）后触发，参数为新绝对路径。
+    /** 本客户端成功切换工作区（set_cwd）后触发，参数为新绝对路径 + 该项目的额外
+     *  工作区根（多根由用户/插件经 set_workspace_roots 设置，见 protocol）。
      *  attach 时由 AgentService 接到全局 onClientCwdChanged —— 编辑器等
      *  工作区跟随型插件借此把根目录切到用户当前项目。 */
     onCwdChanged = undefined;
+    /** issue #145 跨客户端同会话感知 —— attach 时由 AgentService 接线：
+     *  - findSessionOwner：别处是否已持有同一 session 文件（查重建第二个 writer 用）；
+     *  - listProjectRunners：别处在同一 cwd 下正在跑的对话（同项目并行感知用）；
+     *  - listExternalRunning：别处所有正在跑的对话（左栏「另一处正在运行」用）；
+     *  - notifyExternalClients：向其他客户端广播一条 notice（并行打开时互相通告）；
+     *  - onRunningChanged：本实例流式集合变化时触发，AgentService 借此让其他
+     *    客户端重推 conversations（elsewhere 列表近实时）。 */
+    findSessionOwner = undefined;
+    /** issue #145：除本客户端外是否有人在跑（扫目录查重前置的无 I/O 判断）。 */
+    hasStreamingElsewhere = undefined;
+    listProjectRunners = undefined;
+    listExternalRunning = undefined;
+    notifyExternalClients = undefined;
+    onRunningChanged = undefined;
     /** Ask the npm registry for the latest pi-web-ui version and report it. */
     async checkUpdate() {
         const current = ClientSession.currentAppVersion();
         try {
+            // registry 遵从 <agentDir>/npm/.npmrc（与 `pi update` 经 npm 的行为一致，
+            // issue #151）；私有源的 token 也一并带上，否则直接 401。
+            const { registry, authHeader } = resolveNpmRegistry(this.agentDir);
             // Fetch the full package doc (not /latest): it carries the per-version
             // publish timestamps so the UI can hint when a version was JUST
             // published and the registry/CDN caches may not have caught up yet.
-            const res = await fetch("https://registry.npmjs.org/pi-web-ui", {
+            const res = await fetch(`${registry}/pi-web-ui`, {
                 signal: AbortSignal.timeout(8_000),
+                ...(authHeader ? { headers: { authorization: authHeader } } : {}),
             });
             if (!res.ok)
                 throw new Error(`HTTP ${res.status}`);
@@ -2993,7 +3044,7 @@ export class ClientSession {
         }
         try {
             const targets = collectTargets(this.agentDir, ClientSession.currentAppVersion());
-            const items = await checkAllUpdates(targets, undefined, () => this.getLang());
+            const items = await checkAllUpdates(targets, undefined, () => this.getLang(), resolveNpmRegistry(this.agentDir));
             this.updatesAllCache = { at: Date.now(), items };
             this.emit({ type: "update_status_all", items });
         }
@@ -3490,6 +3541,86 @@ export class ClientSession {
             n += c.queueFollowUp.length + c.queueSteering.length;
         return n;
     }
+    /** issue #145：本实例连接的 socket 数（0 = 标签页全关了，ClientSession 残留）。 */
+    sinkCount() {
+        return this.sinks.size;
+    }
+    /** issue #145：按下 session 文件找本实例持有的对话（跨客户端查重的本机一半）。 */
+    findConversationBySessionFile(targetPath) {
+        for (const conv of this.convs.values()) {
+            try {
+                const sessionFile = conv.session.sessionFile;
+                if (sessionFile && resolve(sessionFile) === targetPath)
+                    return conv;
+            }
+            catch {
+                // session being replaced — skip
+            }
+        }
+        return undefined;
+    }
+    /** issue #145：某对话是否正在流式运行（替换中按未跑处理，不误拦）。 */
+    conversationStreaming(conv) {
+        try {
+            return conv.session.isStreaming;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** issue #145：当前活动对话的 session 文件（resolved），无则 undefined。 */
+    activeSessionFileResolved() {
+        try {
+            const conv = this.convs.get(this.activeId);
+            const f = conv?.session.sessionFile;
+            return f ? resolve(f) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** issue #145：本实例在某 cwd 下正在跑的对话摘要（同项目并行感知用）。 */
+    streamingInCwd(cwd) {
+        const out = [];
+        for (const conv of this.convs.values()) {
+            if (conv.cwd !== cwd || conv.isSubagent)
+                continue;
+            if (!this.conversationStreaming(conv))
+                continue;
+            let sessionFile;
+            try {
+                sessionFile = conv.session.sessionFile ?? undefined;
+            }
+            catch {
+                sessionFile = undefined;
+            }
+            out.push({ convId: conv.id, title: conv.title, sessionFile });
+        }
+        return out;
+    }
+    /** issue #145：本实例所有正在跑的对话摘要（elsewhere 列表的本机一半）。 */
+    streamingSummariesAll() {
+        const out = [];
+        for (const conv of this.convs.values()) {
+            if (conv.isSubagent)
+                continue;
+            if (!this.conversationStreaming(conv))
+                continue;
+            out.push({ title: conv.title, cwd: conv.cwd, isStreaming: true });
+        }
+        return out;
+    }
+    /** issue #145：让其他客户端重推 conversations（elsewhere 刷新用；
+     *  流式集合签名驱动，外层循环安全）。 */
+    refreshExternalRunning() {
+        if (this.disposed)
+            return;
+        this.emitConversations();
+    }
+    /** issue #145：AgentService 代其他客户端向本客户端广播 notice（并行通告用）。 */
+    sendNotice(msg) {
+        this.emit(msg);
+    }
     async prompt(text, attachments, 
     /**
      * true = followUp: while streaming, queue the prompt and deliver it only
@@ -3518,6 +3649,73 @@ export class ClientSession {
             // is refused until admission reopens.
             if (this.quiesceBlocked())
                 return;
+            // issue #145：发之前再查一次同文件持有者 —— 拦住「打开时空闲、发送时在跑」的竞态。
+            // 没有第二个 writer，就不可能有看不见的第二个 agent。
+            const activeFile = this.activeSessionFileResolved();
+            if (activeFile) {
+                const owner = this.findSessionOwner?.(activeFile);
+                if (owner && owner.isStreaming) {
+                    this.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `发送已拦截：该对话正在另一处运行中（「${owner.title}」）。请等它结束后再发，或回到原窗口继续 —— 否则两个 agent 会同时写同一份记录，其中一支事后不可见。`,
+                        textEn: `Prompt blocked: this conversation is running in another window ("${owner.title}"). Wait for it to finish or continue there — two writers on one transcript would leave one run permanently invisible.`,
+                    });
+                    this.flushSnapshot();
+                    return;
+                }
+            }
+            // issue #145：同项目并行感知 —— 同一 cwd 下别处（或其他对话）正在跑时，
+            // 允许并行（可以同时改不同部分），但用户与 AI 都必须知道。只在新一轮启动时
+            // 通告一次（steer/排队等流式中发送不重复打扰）。
+            if (!conv.isSubagent && !s.isStreaming) {
+                const localRunners = [...this.convs.values()]
+                    .filter((c) => c.id !== conv.id && !c.isSubagent && c.cwd === conv.cwd && this.conversationStreaming(c))
+                    .map((c) => ({ title: c.title }));
+                const externalRunners = (this.listProjectRunners?.(conv.cwd) ?? []).filter((r) => r.sessionFile === undefined || (activeFile !== undefined && resolve(r.sessionFile) !== activeFile));
+                const runnerTitles = [
+                    ...localRunners.map((r) => `本窗口「${r.title}」`),
+                    ...externalRunners.map((r) => `另一处「${r.title}」`),
+                ];
+                if (runnerTitles.length > 0) {
+                    const shown = runnerTitles.slice(0, 3).join("、");
+                    const more = runnerTitles.length > 3 ? `等 ${runnerTitles.length} 处` : "";
+                    this.emit({
+                        type: "notice",
+                        level: "info",
+                        text: `同项目并行提醒：${shown}${more}正在同一项目运行。你可以继续（适合改不同文件），改动同一文件前请先确认；拿不准就等它跑完。`,
+                        textEn: `Parallel-work notice: ${shown}${more ? " and more" : ""} running in the same project. You may continue (fine for different files); confirm before touching the same files, or wait for it to finish when unsure.`,
+                    });
+                    // 给 AI 的上下文：评估冲突概率，拿不准就 ask_user_question 让用户选
+                    // （并行 / 等它跑完 / 只读围观）。display:false —— 用户界面只看上面的 notice。
+                    const aiReminder = `(System reminder: ${runnerTitles.length} other run(s) [${runnerTitles.join("; ").slice(0, 600)}] ` +
+                        `are currently running in the same project directory. You may work in parallel on different files, ` +
+                        `but before reading/writing files or running commands, assess the conflict probability with the other run(s) ` +
+                        `(same files? same commands? migrations?). If a conflict is likely or you are unsure, ` +
+                        `use ask_user_question to let the user choose: continue in parallel / wait / watch read-only.)\n` +
+                        `（系统提醒：同一项目另有 ${runnerTitles.length} 处运行（${shown}${more}）。改不同文件可并行；` +
+                        `读写文件或跑命令前先评估冲突概率，拿不准就用 ask_user_question 让用户选择：并行 / 等它跑完 / 只读围观。）`;
+                    try {
+                        await s.sendCustomMessage({
+                            customType: "parallel-work-reminder",
+                            content: [{ type: "text", text: aiReminder }],
+                            display: false,
+                        }, { deliverAs: "nextTurn" });
+                    }
+                    catch {
+                        // best effort —— 注入失败不影响发送本身
+                    }
+                    // 让对端也知道：有人在同项目开了并行工作（只通知其他客户端，不打扰自己）。
+                    if (externalRunners.length > 0) {
+                        this.notifyExternalClients?.({
+                            type: "notice",
+                            level: "info",
+                            text: `同项目并行提醒：另一处在「${conv.cwd}」开始了对话（「${conv.title}」），可能与你正在跑的任务并行改动同一项目。`,
+                            textEn: `Parallel-work notice: another window started a conversation ("${conv.title}") in "${conv.cwd}", possibly editing the same project in parallel with your running task.`,
+                        });
+                    }
+                }
+            }
             // 轨迹用：暂存本轮任务文本，下一轮 agent_start 消费（steer/内部续跑
             // 不经此处，届时 task 缺省，插件回退为「继续执行」）。
             conv.pendingTask = text.trim() ? truncRun(text.trim(), RUN_TASK_CAP) : undefined;
@@ -4036,6 +4234,108 @@ export class ClientSession {
      *   caller must drop it (returns it so removal happens only after the
      *   active conversation has been switched away).
      */
+    /** Write a pending-compaction marker into the session file. The SDK treats
+     *  unknown custom entries as inert data, so a crash/restart-safe "we were
+     *  compacting" record survives in the transcript itself — no sidecar file
+     *  to orphan or clean up. Removed on compaction_end. */
+    markCompactionPending(conv) {
+        try {
+            const file = conv.session.sessionFile;
+            if (!file)
+                return;
+            // parentId joins the live chain: a null-parent marker would become a
+            // second root and hijack the leaf, corrupting the transcript.
+            const marker = {
+                type: "custom",
+                id: "pi-web-ui-compaction-pending",
+                parentId: conv.session.sessionManager.getLeafId(),
+                timestamp: new Date().toISOString(),
+                customType: "pi-web-ui/compaction-pending",
+                data: {
+                    reason: conv.compactionState?.reason ?? "manual",
+                    startedAt: conv.compactionState?.startedAt ?? Date.now(),
+                },
+            };
+            appendFileSync(file, `${JSON.stringify(marker)}\n`);
+        }
+        catch {
+            // Marker is best-effort: compaction still runs without it, only the
+            // restart-detection below is lost.
+        }
+    }
+    /** Close out the pending-compaction marker (called on compaction_end). The
+     *  session file is append-only through the SDK, so rewrite the file with the
+     *  pending marker replaced by a completion marker carrying the outcome
+     *  (completed / failed / cancelled + token counts). The transcript then holds
+     *  a durable started→finished record instead of a silent gap. No-op when the
+     *  file or marker is absent. */
+    clearCompactionPending(conv, outcome) {
+        try {
+            const file = conv.session.sessionFile;
+            if (!file || !existsSync(file))
+                return;
+            const id = "pi-web-ui-compaction-pending";
+            const raw = readFileSync(file, "utf8");
+            const lines = raw.split("\n");
+            const idx = lines.findIndex((line) => line.includes(`"${id}"`));
+            if (idx < 0)
+                return;
+            // ponytail: full-file rewrite on compaction end — compactions are rare
+            // (seconds apart at most), session files are KBs; no streaming needed.
+            if (!outcome) {
+                lines.splice(idx, 1);
+            }
+            else {
+                let parentId = null;
+                try {
+                    parentId = conv.session.sessionManager.getLeafId();
+                }
+                catch {
+                    // fall through with null parent
+                }
+                const done = {
+                    type: "custom",
+                    id: "pi-web-ui-compaction-done",
+                    parentId,
+                    timestamp: new Date().toISOString(),
+                    customType: "pi-web-ui/compaction-done",
+                    data: { reason: conv.compactionState?.reason ?? "manual", ...outcome },
+                };
+                lines[idx] = JSON.stringify(done);
+            }
+            writeFileSync(file, lines.join("\n"));
+        }
+        catch {
+            // Best-effort, same as the write path.
+        }
+    }
+    /** Check a freshly opened session for a leftover compaction-pending marker.
+     *  A marker with no matching compaction_end means the server died mid-compaction
+     *  (restart/crash): the in-flight summary is gone, but the session is intact.
+     *  Surface a warning notice with a one-click retry (/compact) instead of
+     *  silently dropping it. Consumes the marker either way. */
+    noticeInterruptedCompaction(conv) {
+        try {
+            const file = conv.session.sessionFile;
+            if (!file || !existsSync(file))
+                return;
+            // Match on the stable customType (conversation ids change every restart).
+            const raw = readFileSync(file, "utf8");
+            if (!raw.includes('"pi-web-ui/compaction-pending"'))
+                return;
+            const kept = raw.split("\n").filter((line) => !line.includes("pi-web-ui/compaction-pending"));
+            writeFileSync(file, kept.join("\n"));
+            this.emit({
+                type: "notice",
+                level: "warning",
+                text: "上次压缩上下文被服务端重启打断，未完成。可发送 /compact 重试。",
+                textEn: "The last context compaction was interrupted by a server restart and did not finish. Send /compact to retry.",
+            });
+        }
+        catch {
+            // Best-effort, same as the write path.
+        }
+    }
     displaceActive() {
         const conv = this.conv;
         // 子代理不受切换关闭影响（见上）。
@@ -4068,6 +4368,7 @@ export class ClientSession {
                 reviewing: conv.goal.reviewing,
                 wizardRunning: conv.wizardRunning,
                 streaming: conv.session.isStreaming,
+                compacting: conv.session.isCompacting,
                 openTerminals: conv.terminals.countLive(),
                 listed: conv.listed,
                 promptedSinceActive: conv.promptedSinceActive,
@@ -4118,12 +4419,13 @@ export class ClientSession {
         void this.pushSlashCommands();
         if (cwdChanged) {
             this.cwd = newCwd;
+            this.roots = this.stateStore.getWorkspaceRoots(this.clientId, newCwd);
             await this.restoreProjectProviderKeysForCwd(newCwd);
             await this.restoreProjectModelForCwd(newCwd);
             // Mirror set_cwd's project-switch side-effects so the whole UI follows
             // the new workspace, not just the chat pane.
             try {
-                this.onCwdChanged?.(newCwd);
+                this.onCwdChanged?.(newCwd, this.roots);
             }
             catch {
                 /* hook failure must not break the switch */
@@ -4204,13 +4506,34 @@ export class ClientSession {
                 parentId: conv.parentId,
             });
         }
+        // issue #145：流式集合签名变化 → 通知其他客户端重推（左栏「另一处正在运行」近实时）
+        try {
+            const sig = JSON.stringify([...this.convs.values()]
+                .filter((c) => this.conversationStreaming(c))
+                .map((c) => c.id)
+                .sort());
+            if (sig !== this.lastRunningSig) {
+                this.lastRunningSig = sig;
+                this.onRunningChanged?.();
+            }
+        }
+        catch {
+            // 会话替换中——跳过本轮签名比较
+        }
+        const elsewhere = this.listExternalRunning?.() ?? [];
         this.emit({
             type: "conversations",
             conversations,
             activeId: this.activeId,
+            // 为空时缺省（老快照字节一致）
+            ...(elsewhere.length > 0 ? { elsewhere } : {}),
         });
     }
     /** List persisted sessions for this client, newest first. */
+    /** issue #145：上次 emit 时本实例流式对话 id 集合签名。变化时经
+     *  onRunningChanged 让其他客户端重推 conversations（elsewhere 近实时）；
+     *  签名相等即停，天然防 ping-pong 循环。 */
+    lastRunningSig = "";
     /** The client asked for the session list at least once (lazy loading) —
      *  background refreshes only re-push when this is true, so a mobile
      *  client that never opened the panel never pays the disk scan. */
@@ -4885,6 +5208,32 @@ export class ClientSession {
                     return;
                 }
             }
+            // issue #145：同一文件在别处已有持有者 —— 绝不建第二个 writer。
+            // 正在跑：直接拒绝（否则两支 run 并发写同一份 JSONL，事后只有一支可读）；
+            // 空闲：放行打开（只剩一处能发送时不会分叉），但提醒用户别处也开着，
+            // 发消息前的 prompt() 守卫会再查一次（开时空闲、发时在跑的竞态也拦得住）。
+            const owner = this.findSessionOwner?.(targetPath);
+            if (owner && owner.isStreaming) {
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `该对话正在另一处运行中（「${owner.title}」），为避免两个 agent 同时写同一份记录，已停止打开。请等它结束后再试，或回到原窗口继续。`,
+                    textEn: `This conversation is running in another window ("${owner.title}"). Opening it here would create a second writer for the same transcript, so it was blocked. Wait for it to finish, or continue in the original window.`,
+                });
+                this.flushSnapshot();
+                return;
+            }
+            if (owner) {
+                // 对端已断开（标签页关了）只剩残留会话 —— 不打扰，直接开。
+                if (owner.connected) {
+                    this.emit({
+                        type: "notice",
+                        level: "info",
+                        text: `提醒：该对话在另一处也开着（「${owner.title}」，当前空闲）。请只留一处发送消息，否则两边轮流发送会让历史分叉、其中一支事后不可见。`,
+                        textEn: `Note: this conversation is also open in another window ("${owner.title}", currently idle). Send new messages from only one place — alternating between two writers forks the history and hides one branch.`,
+                    });
+                }
+            }
             const sessionManager = SessionManager.open(targetPath);
             const targetCwd = sessionManager.getCwd();
             const conversationId = this.nextConversationId();
@@ -4922,6 +5271,7 @@ export class ClientSession {
             // Deliberately resumed — must not be dismissed when the user later
             // switches away without sending a new message.
             conv.promptedSinceActive = true;
+            this.noticeInterruptedCompaction(conv);
             this.convs.set(conv.id, conv);
             this.activeId = conv.id;
             openedRuntime = null;
@@ -5186,6 +5536,38 @@ export class ClientSession {
     async completePath(input) {
         return this.files.completePath(input);
     }
+    /** 当前项目的额外工作区根（空数组 = 单根）。 */
+    get workspaceRoots() {
+        return this.roots;
+    }
+    /**
+     * 设置当前项目的额外工作区根（宿主侧多根，见 protocol 的 set_workspace_roots）。
+     *
+     * 语义：AI 仍只在主 cwd 里干活（pi SDK 是单 cwd 模型），多根只影响「哪些路径算
+     * 工作区内」—— 右栏文件树可跨根浏览，插件的 host.fs / host.project.create 不必
+     * 再走授权就能读这些根（所以它是用户/宿主侧动作，不是插件能静默做的）。
+     *
+     * 归一化交给 ClientStateStore（只收绝对路径 / 去重 / 上限 8）。刻意**不**校验
+     * 目录是否存在：根可能是暂时断开的盘或挂载点，不该把用户设过的根静默清掉。
+     */
+    async setWorkspaceRoots(roots) {
+        const before = this.stateStore.getWorkspaceRoots(this.clientId, this.cwd);
+        this.stateStore.saveWorkspaceRoots(this.clientId, this.cwd, roots ?? []);
+        const saved = this.stateStore.getWorkspaceRoots(this.clientId, this.cwd);
+        if (saved.length === before.length && saved.every((p, i) => p === before[i])) {
+            // 没变化（重复点 / 重放的旧命令）：不打扰插件、不推快照。
+            return;
+        }
+        this.roots = saved;
+        try {
+            // 同一个钩子：插件宿主要跟着把「工作区内的路径」重新算一遍。
+            this.onCwdChanged?.(this.cwd, this.roots);
+        }
+        catch {
+            /* 钩子异常不影响主流程 */
+        }
+        this.flushSnapshot();
+    }
     async setCwd(newCwd) {
         try {
             const { resolve, sep } = await import("node:path");
@@ -5240,13 +5622,34 @@ export class ClientSession {
                     this.removeConversation(displaced.id);
             }
             else {
-                // First visit to this project: resume its most recent session.
+                // First visit to this project: resume its most recent session —
+                // unless that transcript is streaming on another client (#145):
+                // default-opening it would strand the tab on a conversation it
+                // cannot use (the prompt guard refuses) with a stale leaf that
+                // forks history once the owner finishes. Land blank instead.
+                let sessionManager = SessionManager.continueRecent(abs);
+                let resumeSkipped = null;
+                // 无人在跑时不扫目录（首访切项目的常见情形零开销）。
+                if (this.hasStreamingElsewhere?.() ?? false) {
+                    try {
+                        const infos = await SessionManager.list(abs, piSessionsRoot());
+                        const recent = infos[0]?.path ? resolve(infos[0].path) : undefined;
+                        const owner = recent ? this.findSessionOwner?.(recent) : null;
+                        if (owner?.isStreaming) {
+                            sessionManager = SessionManager.create(abs);
+                            resumeSkipped = owner;
+                        }
+                    }
+                    catch {
+                        // 列表失败不挡正常恢复
+                    }
+                }
                 const conversationId = this.nextConversationId();
                 const terminals = this.makeTerminalManager(conversationId, abs);
                 const newRuntime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals, undefined, conversationId), {
                     cwd: abs,
                     agentDir: this.agentDir,
-                    sessionManager: SessionManager.continueRecent(abs),
+                    sessionManager,
                 });
                 const conv = this.makeConversation(newRuntime, conversationId, terminals);
                 this.convs.set(conv.id, conv);
@@ -5259,16 +5662,25 @@ export class ClientSession {
                     }
                 }
                 await this.bindSession();
+                if (resumeSkipped) {
+                    this.emit({
+                        type: "notice",
+                        level: "info",
+                        text: `该项目最近的对话「${resumeSkipped.title}」正在另一处运行，为你停在了新对话 —— 直接打开会造出第二个写者。左栏「运行的对话」里能看到它（标着“另一处”），等它跑完再打开。`,
+                        textEn: `The most recent conversation ("${resumeSkipped.title}") is running in another window, so you landed on a new chat instead — opening it here would create a second writer. It is listed under Running chats (tagged "Elsewhere"); open it after it finishes.`,
+                    });
+                }
             }
             this.pushTerminals();
             this.conv.promptedSinceActive = false;
             this.conv.lastActiveAt = Date.now();
             this.cwd = abs;
+            this.roots = this.stateStore.getWorkspaceRoots(this.clientId, abs);
             await this.restoreProjectProviderKeysForCwd(abs);
             await this.restoreProjectModelForCwd(abs);
             // 工作区跟随型插件（编辑器文件树等）同步切根。
             try {
-                this.onCwdChanged?.(abs);
+                this.onCwdChanged?.(abs, this.roots);
             }
             catch {
                 /* 钩子异常不影响主流程 */
@@ -5518,8 +5930,9 @@ export class AgentService {
     stateStore;
     /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
     onQuit = undefined;
-    /** 任意客户端成功切换工作区后触发（新绝对路径）。index.ts 接到
-     *  PluginManager.notifyCwd，让插件宿主的 host.cwd 实时跟随当前项目。 */
+    /** 任意客户端成功切换工作区后触发（新绝对路径 + 该项目的额外工作区根）。
+     *  index.ts 接到 PluginManager.notifyCwd / notifyWorkspaceRoots，让插件宿主的
+     *  host.cwd 实时跟随当前项目、受支持路径范围跟着多根变。 */
     onClientCwdChanged = undefined;
     constructor(cwd, stateFile) {
         this.cwd = cwd;
@@ -5544,6 +5957,89 @@ export class AgentService {
     quiesceInfo() {
         return this.quiesced ? { quiesced: true, quiescedSince: this.quiescedAt } : { quiesced: false };
     }
+    /** issue #145：除请求方外是否有客户端正在跑（扫目录查重前置的无 I/O 判断）。 */
+    hasStreamingElsewhere(excludeClientId) {
+        for (const [clientId, cs] of this.clients) {
+            if (clientId === excludeClientId)
+                continue;
+            try {
+                if (cs.activeConversations() > 0)
+                    return true;
+            }
+            catch {
+                // 单客户端坏了不影响判断
+            }
+        }
+        return false;
+    }
+    /** issue #145：跨客户端同会话查重 —— 找持有某 session 文件的别处对话。
+     *  调用方在 SessionManager.open() 之前问这一句，就造不出第二个 writer。 */
+    findSessionOwner(targetPath, excludeClientId) {
+        for (const [clientId, cs] of this.clients) {
+            if (clientId === excludeClientId)
+                continue;
+            const conv = cs.findConversationBySessionFile(targetPath);
+            if (conv) {
+                return {
+                    clientId,
+                    title: conv.title,
+                    cwd: conv.cwd,
+                    isStreaming: cs.conversationStreaming(conv),
+                    connected: cs.sinkCount() > 0,
+                };
+            }
+        }
+        return null;
+    }
+    /** issue #145：别处在某 cwd 下正在跑的对话（同项目并行感知用，不含请求方）。 */
+    listProjectRunners(cwd, excludeClientId) {
+        const out = [];
+        for (const [clientId, cs] of this.clients) {
+            if (clientId === excludeClientId)
+                continue;
+            for (const r of cs.streamingInCwd(cwd))
+                out.push({ clientId, title: r.title, sessionFile: r.sessionFile });
+        }
+        return out;
+    }
+    /** issue #145：别处所有正在跑的对话（左栏 elsewhere 只读感知用）。 */
+    listExternalRunning(excludeClientId) {
+        const out = [];
+        for (const [clientId, cs] of this.clients) {
+            if (clientId === excludeClientId)
+                continue;
+            for (const r of cs.streamingSummariesAll())
+                out.push(r);
+        }
+        return out;
+    }
+    /** issue #145：某客户端流式集合变化 → 其他客户端重推 conversations。 */
+    pokeExternalRunning(excludeClientId) {
+        for (const [clientId, cs] of this.clients) {
+            if (clientId === excludeClientId)
+                continue;
+            try {
+                cs.refreshExternalRunning();
+            }
+            catch {
+                // 单客户端坏了不影响其他
+            }
+        }
+    }
+    /** issue #145：向除请求方外的所有客户端发一条 notice（并行通告用）。 */
+    notifyClientsExcept(excludeClientId, msg) {
+        for (const [clientId, cs] of this.clients) {
+            if (clientId === excludeClientId)
+                continue;
+            try {
+                // 经 ClientSession.emit 才能进该客户端的 sink 组播；用公开发送面。
+                cs.sendNotice(msg);
+            }
+            catch {
+                // 单客户端坏了不影响其他
+            }
+        }
+    }
     /** Aggregate across every client session: conversations with in-flight runs. */
     activeConversations() {
         let n = 0;
@@ -5644,12 +6140,35 @@ export class AgentService {
                     }
                 }
                 // Sessions use the SDK default per-project dir — no per-client dir.
-                const creating = ClientSession.create(clientId, cwd, this.stateStore).finally(() => {
+                // issue #145：新标签页默认恢复项目最近的会话 —— 若那条在别处跑着，
+                // 建之前就决定空白（第二个 writer 根本不会被打开，也无需事后拆 runtime）。
+                // 先做无 I/O 的便宜判断，无人在跑时不扫目录。
+                let createOpts;
+                if (this.hasStreamingElsewhere(clientId)) {
+                    try {
+                        const infos = await SessionManager.list(cwd, piSessionsRoot());
+                        const recent = infos[0]?.path ? resolve(infos[0].path) : undefined;
+                        const owner = recent ? this.findSessionOwner(recent, clientId) : null;
+                        if (owner?.isStreaming)
+                            createOpts = { blank: true, blankTitle: owner.title };
+                    }
+                    catch {
+                        // 列表失败不挡正常恢复
+                    }
+                }
+                const creating = ClientSession.create(clientId, cwd, this.stateStore, createOpts).finally(() => {
                     this.pending.delete(clientId);
                 });
                 this.pending.set(clientId, creating);
                 cs = await creating;
                 this.clients.set(clientId, cs);
+                // issue #145 接线提前：首帧 elsewhere 依赖它。
+                cs.findSessionOwner = (targetPath) => this.findSessionOwner(targetPath, clientId);
+                cs.hasStreamingElsewhere = () => this.hasStreamingElsewhere(clientId);
+                cs.listProjectRunners = (cwd) => this.listProjectRunners(cwd, clientId);
+                cs.listExternalRunning = () => this.listExternalRunning(clientId);
+                cs.notifyExternalClients = (msg) => this.notifyClientsExcept(clientId, msg);
+                cs.onRunningChanged = () => this.pokeExternalRunning(clientId);
                 // Make sure the restored/default workspace appears in the project list.
                 this.stateStore.remember(clientId, cwd);
                 if (cwd !== this.cwd) {
@@ -5677,10 +6196,17 @@ export class AgentService {
         cs.pluginBgTasksProvider = this.pluginBgTasksProvider;
         cs.pluginStopBgTask = this.pluginStopBgTask;
         cs.isQuiesced = () => this.quiesced;
+        // issue #145 跨客户端感知接线（同会话查重 / 同项目并行 / elsewhere 列表）。
+        cs.findSessionOwner = (targetPath) => this.findSessionOwner(targetPath, clientId);
+        cs.hasStreamingElsewhere = () => this.hasStreamingElsewhere(clientId);
+        cs.listProjectRunners = (cwd) => this.listProjectRunners(cwd, clientId);
+        cs.listExternalRunning = () => this.listExternalRunning(clientId);
+        cs.notifyExternalClients = (msg) => this.notifyClientsExcept(clientId, msg);
+        cs.onRunningChanged = () => this.pokeExternalRunning(clientId);
         // 插件宿主工作区跟随：初次接入也同步一次（恢复的 lastCwd 可能≠服务启动目录），
         // notifyCwd 幂等去重；此后 set_cwd 成功时由 cs.onCwdChanged 继续驱动。
-        cs.onCwdChanged = (abs) => this.onClientCwdChanged?.(abs);
-        this.onClientCwdChanged?.(cs.cwd);
+        cs.onCwdChanged = (abs, roots) => this.onClientCwdChanged?.(abs, roots);
+        this.onClientCwdChanged?.(cs.cwd, cs.workspaceRoots);
         return cs;
     }
     /** 插件 AI 工具集合变化（注册/注销）时由 index.ts 触发：推送到所有客户端的全部会话。 */