wave-code 1.2.0 → 1.3.0

package/src/stdio/agentBridge.ts

@@ -36,6 +36,8 @@ import {
   type PartialHookConfiguration,
   isValidHookEvent,
   listSessions,
+  listAllSessions,
+  setSessionCustomTitle,
   searchFiles,
   generateRandomName,
   getDefaultRemoteBranch,
@@ -49,8 +51,13 @@ import {
   loadWaveConfigFromFile,
   getUserConfigPaths,
   getProjectConfigPaths,
+  readUserPreferenceView,
+  updateUserPreferenceSettings,
+  type UserPreferenceSettings,
+  type UserPreferenceSettingsView,
   type SubagentConfiguration,
   type SkillMetadata,
+  type PluginReloadResult,
 } from "wave-agent-sdk";
 import {
   type JsonRpcError,
@@ -95,7 +102,6 @@ interface InitializeParams {
   defaultHeaders?: Record<string, string>;
   model?: string;
   fastModel?: string;
-  language?: string;
   permissionMode?: PermissionMode;
   tools?: string[];
   allowedTools?: string[];
@@ -104,11 +110,11 @@ interface InitializeParams {
   mcpServers?: Record<string, McpServerConfig>;
   worktreeName?: string;
   isNewWorktree?: boolean;
-  /** Settings-page auto-memory toggle/frequency (session-level override). */
-  autoMemoryEnabled?: boolean;
-  autoMemoryFrequency?: number;
 }
 
+// 会话级覆盖项：用户偏好（语言 / 上下文长度 / 自动记忆开关与频率）不在此层——
+// 它们落用户级 ~/.wave/settings.json 经实时重载生效（getUserSettings /
+// updateUserSettings），走覆盖层会永久遮蔽 settings.json 的实时值。
 interface UpdateConfigParams {
   apiKey?: string;
   baseURL?: string;
@@ -116,10 +122,6 @@ interface UpdateConfigParams {
   defaultHeaders?: Record<string, string>;
   model?: string;
   fastModel?: string;
-  language?: string;
-  /** Settings-page auto-memory toggle/frequency (session-level override). */
-  autoMemoryEnabled?: boolean;
-  autoMemoryFrequency?: number;
 }
 
 interface SearchFilesParams {
@@ -141,6 +143,24 @@ interface SessionEntry {
    * header when the session is re-attached from disk after a daemon restart.
    */
   createdWorkdir: string;
+  /**
+   * True while `updateConfig` is tearing the session's agent down and rebuilding
+   * it from the updated config — the entry stays in the registry (so the session
+   * does not look deleted to a `wait` that is blocked on it) but has no usable
+   * agent. Two consequences, both deliberate:
+   *
+   * - `listDaemonSessions` reports it as `isLoading: true`. The teardown aborts
+   *   the in-flight turn, so the outgoing agent reads `isLoading: false` while the
+   *   rebuild is still running; reporting that would let a `wait` print an idle
+   *   snapshot for a session whose agent is mid-replacement. A waiter that keeps
+   *   waiting is never wrong here — the rebuild is bounded, and if it fails the
+   *   entry is dropped, so the waiter then gets a clear "no longer exists".
+   * - State-changing RPCs refuse it (`requireSession`); a message sent to the
+   *   outgoing agent would be silently lost. Read-only RPCs still work
+   *   (`requireSessionForRead`) and see the outgoing agent's data, which is this
+   *   same session's transcript.
+   */
+  transitioning?: boolean;
 }
 
 /**
@@ -206,6 +226,21 @@ export class AgentBridge {
         return this.restoreSession(p.sessionId as string, sessionId);
       case "listSessions":
         return this.listSessions(p.workdir as string | undefined, sessionId);
+      case "listAllSessions":
+        // Every project on this host (no session required) — the desktop's
+        // /resume picker lists sessions the app never created, so it cannot use
+        // the per-workdir listSessions.
+        return this.listAllSessions();
+      case "renameSession":
+        // Host-level like listAllSessions: the target session may have no live
+        // agent (the desktop renames sessions straight from its sidebar, and a
+        // restored one is not running), so the id/workdir come from the caller
+        // instead of the bound session.
+        return this.renameSession(
+          p.sessionId as string,
+          p.workdir as string,
+          p.title as string,
+        );
       case "getSessionInfo":
         return this.getSessionInfo(sessionId);
       case "listPendingPermissions":
@@ -233,6 +268,15 @@ export class AgentBridge {
       case "setModel":
         return this.setModel(p.model as string, sessionId);
 
+      // ── User preferences (global — user-level ~/.wave/settings.json) ──
+      // 设置页保存路径：用户偏好写文件后由 SDK 实时重载在各会话下一轮生效，
+      // 不经 updateConfig 当 AgentOptions 覆盖层下发（见 protocol.ts 注释）。
+      // 读回的是**生效值**（可能来自 Remote 组织下发/环境变量）+ 每键来源层。
+      case "getUserSettings":
+        return this.userSettingsView();
+      case "updateUserSettings":
+        return this.updateUserSettings(p as UserPreferenceSettings);
+
       // ── Messages ──
       case "sendMessage":
         return this.sendMessage(
@@ -376,6 +420,7 @@ export class AgentBridge {
       case "uninstallPlugin":
         return this.uninstallPlugin(
           p.pluginId as string,
+          p.scope as Scope | undefined,
           p.workdir as string | undefined,
           sessionId,
         );
@@ -424,11 +469,25 @@ export class AgentBridge {
           p.workdir as string | undefined,
           sessionId,
         );
+      case "setPluginScope":
+        return this.setPluginScope(
+          p.pluginId as string,
+          p.scope as Scope,
+          p.workdir as string | undefined,
+          sessionId,
+        );
+      case "reloadPlugins":
+        return this.reloadPlugins();
       case "listMarketplaces":
         return this.listMarketplaces(
           p.workdir as string | undefined,
           sessionId,
         );
+      case "refreshMarketplaces":
+        return this.refreshMarketplaces(
+          p.workdir as string | undefined,
+          sessionId,
+        );
       case "addMarketplace":
         return this.addMarketplace(
           p.input as string,
@@ -552,9 +611,6 @@ export class AgentBridge {
       defaultHeaders: params.defaultHeaders,
       model: params.model,
       fastModel: params.fastModel,
-      language: params.language,
-      autoMemoryEnabled: params.autoMemoryEnabled,
-      autoMemoryFrequency: params.autoMemoryFrequency,
       permissionMode: params.permissionMode,
       tools: params.tools,
       allowedTools: params.allowedTools,
@@ -608,8 +664,30 @@ export class AgentBridge {
     if (sessionId) {
       const entry = this.sessions.get(sessionId);
       if (entry) {
-        await entry.agent.destroy();
+        if (entry.transitioning) {
+          // A rebuild owns this entry (updateConfig): destroying it here would
+          // race the rebuild, which would then re-register a replacement for a
+          // session the caller just destroyed. Refuse loudly instead — the
+          // caller can retry once the reload settles.
+          throw new RpcError(
+            PROTOCOL_INTERNAL_ERROR,
+            `Session ${sessionId} is being reconfigured (config reload in progress), retry shortly`,
+          );
+        }
+        // Drop the registry entry BEFORE awaiting the teardown. Agent.destroy()
+        // aborts the in-flight turn, which pushes `loadingChange:false` — the
+        // exact notification a finished turn pushes — and the teardown itself is
+        // not instant (transcript save, subagent/mcp cleanup, auto-memory drain).
+        // A client blocked in `wait` that is woken by that push re-reads the
+        // registry for the verdict: with the entry still listed (isLoading now
+        // false) it settles as exit 0 on an intermediate snapshot — a false
+        // "finished" for a session that is being removed. With the entry gone the
+        // existence check wins and it reports "no longer exists" (exit 1).
+        // Removed first also means a throwing teardown cannot leave a
+        // half-destroyed agent listed (destroyAll() below clears the map first
+        // for the same reason).
         this.sessions.delete(sessionId);
+        await entry.agent.destroy();
       }
     }
     return null;
@@ -633,7 +711,7 @@ export class AgentBridge {
     restoreId: string,
     sessionId?: string,
   ): Promise<null> {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     // Re-attach to a live session: the SDK restore would no-op (target is
     // already current). Emit the current messages so the freshly attached
     // client — whose router registered only after initialize returned and so
@@ -665,6 +743,18 @@ export class AgentBridge {
       this.emitContextUsage(entry.agent);
       return null;
     }
+    // The replay branch above is safe during an `updateConfig` transition (it
+    // only re-pushes the outgoing agent's own state, which is this session's
+    // transcript). A REAL restore is not: it would load another conversation
+    // into the agent that is about to be destroyed and replaced, so the call
+    // would be silently thrown away together with the outgoing agent. Refuse it
+    // with the same retryable error the mutating RPCs use.
+    if (entry.transitioning) {
+      throw new RpcError(
+        PROTOCOL_INTERNAL_ERROR,
+        `Session ${sessionId} is being reconfigured (config reload in progress), retry shortly`,
+      );
+    }
     await entry.agent.restoreSession(restoreId);
     // A real restore must also re-emit the usage unconditionally: the SDK
     // only fires onLatestTotalTokensChange on a VALUE CHANGE, so restoring a
@@ -717,6 +807,38 @@ export class AgentBridge {
     return { sessions };
   }
 
+  /**
+   * All main sessions across every project directory of this host, newest
+   * first (deduplicated by session id). Each entry carries the session's real
+   * `workdir`, which is what a caller needs to resume it.
+   */
+  private async listAllSessions(): Promise<{ sessions: SessionMetadata[] }> {
+    const sessions = await listAllSessions();
+    return { sessions };
+  }
+
+  /**
+   * Set a session's user-visible title. Works for any session on this host —
+   * the target does not need to be the bound one, or even live.
+   */
+  private async renameSession(
+    sessionId: string,
+    workdir: string,
+    title: string,
+  ): Promise<void> {
+    // A session this host is running keeps the title in memory and writes it
+    // back at its next flush point (exit, compaction, resume, rewind), so a
+    // file-only write here would be clobbered by the stale in-memory value.
+    // Route through the agent; fall back to the file for sessions that are not
+    // bound to this host's process.
+    const bound = this.sessions.get(sessionId)?.agent;
+    if (bound) {
+      await bound.renameSession(title);
+      return;
+    }
+    await setSessionCustomTitle(sessionId, workdir, title);
+  }
+
   // ── Git / worktree ────────────────────────────────────────────
 
   private listGitBranches(workdir?: string): {
@@ -857,7 +979,7 @@ export class AgentBridge {
     permissionMode: PermissionMode;
     availableTools: string[];
   } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return {
       sessionId: entry.agent.sessionId,
       // The recorded creation workdir, not the live agent.workingDirectory:
@@ -878,76 +1000,105 @@ export class AgentBridge {
     const currentSessionId = entry.agent.sessionId;
     // Merge new config into stored config
     entry.storedConfig = { ...entry.storedConfig, ...params };
-    // Destroy and recreate within the same session slot
-    await entry.agent.destroy();
-    this.sessions.delete(currentSessionId);
-
+    // The entry is NOT removed while the agent is replaced: dropping it would
+    // make a `wait` blocked on this session report "no longer exists" (exit 1)
+    // for a session that is alive and merely reloading — a false error, the same
+    // family as the false idle this whole change is about. Instead the entry is
+    // flagged `transitioning` for the whole destroy + recreate, which
+    // `listDaemonSessions` reports as `isLoading: true` (so no reader can see the
+    // "listed + not busy" combination a waiter would settle on) while
+    // state-changing RPCs refuse it (`requireSession`) instead of talking to the
+    // outgoing, dying agent. Read-only RPCs keep working off that agent.
+    entry.transitioning = true;
     const ctx: SessionContext = {};
-    const callbacks = this.createCallbacks(ctx);
-    const options: AgentOptions = {
-      callbacks,
-      workdir: entry.storedConfig.workdir,
-      restoreSessionId: currentSessionId,
-      apiKey: entry.storedConfig.apiKey,
-      baseURL: entry.storedConfig.baseURL,
-      defaultHeaders: entry.storedConfig.defaultHeaders,
-      model: entry.storedConfig.model,
-      fastModel: entry.storedConfig.fastModel,
-      language: entry.storedConfig.language,
-      autoMemoryEnabled: entry.storedConfig.autoMemoryEnabled,
-      autoMemoryFrequency: entry.storedConfig.autoMemoryFrequency,
-      permissionMode: entry.storedConfig.permissionMode,
-      tools: entry.storedConfig.tools,
-      allowedTools: entry.storedConfig.allowedTools,
-      disallowedTools: entry.storedConfig.disallowedTools,
-      plugins: entry.storedConfig.pluginDirs?.map((p) => ({
-        type: "local",
-        path: p,
-      })),
-      mcpServers: entry.storedConfig.mcpServers,
-      // Keep worktree context (permission safety) across recreation, but never
-      // re-fire WorktreeCreate — the hook ran at initial creation.
-      worktreeName: entry.storedConfig.worktreeName,
-      canUseTool: (context: ToolPermissionContext) =>
-        this.canUseTool(context, ctx),
-    };
-
-    let agent: Agent;
     try {
-      agent = await Agent.create(options);
-    } catch (createError) {
-      // The old entry was already destroyed and removed above. If the session
-      // file is missing or unrecoverable (fresh session, cleared chat, or a
-      // never-persisted empty session), fail soft: recreate WITHOUT
-      // restoreSessionId so this session slot keeps working. Without this the
-      // client's sessionId still points at the destroyed entry and every later
-      // request fails with "Session not found" until the window is reloaded.
-      // Non-session errors (bad baseURL/apiKey/config) must surface unchanged.
-      if (!options.restoreSessionId || !isSessionRecoveryError(createError)) {
-        throw createError;
+      // Destroy and recreate within the same session slot. The destroy comes
+      // first so the outgoing agent stops writing the transcript before the
+      // replacement loads it.
+      await entry.agent.destroy();
+
+      const callbacks = this.createCallbacks(ctx);
+      const options: AgentOptions = {
+        callbacks,
+        workdir: entry.storedConfig.workdir,
+        restoreSessionId: currentSessionId,
+        apiKey: entry.storedConfig.apiKey,
+        baseURL: entry.storedConfig.baseURL,
+        defaultHeaders: entry.storedConfig.defaultHeaders,
+        model: entry.storedConfig.model,
+        fastModel: entry.storedConfig.fastModel,
+        permissionMode: entry.storedConfig.permissionMode,
+        tools: entry.storedConfig.tools,
+        allowedTools: entry.storedConfig.allowedTools,
+        disallowedTools: entry.storedConfig.disallowedTools,
+        plugins: entry.storedConfig.pluginDirs?.map((p) => ({
+          type: "local",
+          path: p,
+        })),
+        mcpServers: entry.storedConfig.mcpServers,
+        // Keep worktree context (permission safety) across recreation, but never
+        // re-fire WorktreeCreate — the hook ran at initial creation.
+        worktreeName: entry.storedConfig.worktreeName,
+        canUseTool: (context: ToolPermissionContext) =>
+          this.canUseTool(context, ctx),
+      };
+
+      let agent: Agent;
+      try {
+        agent = await Agent.create(options);
+      } catch (createError) {
+        // The old agent is already destroyed. If the session file is missing or
+        // unrecoverable (fresh session, cleared chat, or a never-persisted empty
+        // session), fail soft: recreate WITHOUT restoreSessionId so this session
+        // slot keeps working. Without this the client's sessionId still points at
+        // the destroyed entry and every later request fails with "Session not
+        // found" until the window is reloaded. Non-session errors (bad
+        // baseURL/apiKey/config) must surface unchanged.
+        if (!options.restoreSessionId || !isSessionRecoveryError(createError)) {
+          throw createError;
+        }
+        logger?.warn(
+          `updateConfig: failed to restore session ${currentSessionId}, recreating as a fresh session:`,
+          createError,
+        );
+        agent = await Agent.create({ ...options, restoreSessionId: undefined });
       }
-      logger?.warn(
-        `updateConfig: failed to restore session ${currentSessionId}, recreating as a fresh session:`,
-        createError,
-      );
-      agent = await Agent.create({ ...options, restoreSessionId: undefined });
+      ctx.agent = agent;
+      ctx.registeredSessionId = agent.sessionId;
+      entry.agent = agent;
+      // A recovery-recreated session gets a NEW id: move the registry key with it.
+      // (The entry object is reused, so the flag and the recorded creation workdir
+      // survive either way.) Announced with the OLD id as the envelope — same
+      // contract as `onSessionIdChange` — so a client blocked on this session can
+      // rebind to the new id instead of concluding it disappeared.
+      if (agent.sessionId !== currentSessionId) {
+        this.emit(
+          "sessionIdChange",
+          { sessionId: agent.sessionId },
+          currentSessionId,
+        );
+        this.sessions.delete(currentSessionId);
+        this.sessions.set(agent.sessionId, entry);
+      }
+      entry.transitioning = false;
+      return { sessionId: agent.sessionId };
+    } catch (teardownError) {
+      // Nothing usable is left: the outgoing agent is torn down (fully or
+      // partially) and no replacement was built. Leaving the entry listed would
+      // be a "half-dead" session — reachable through the registry but with no
+      // working agent — so it is dropped, exactly like a failing `destroy`: a
+      // waiter then reports "no longer exists" (exit 1) instead of hanging or
+      // settling. The error surfaces to the caller unchanged.
+      this.sessions.delete(currentSessionId);
+      throw teardownError;
     }
-    ctx.agent = agent;
-    ctx.registeredSessionId = agent.sessionId;
-    this.sessions.set(agent.sessionId, {
-      agent,
-      storedConfig: { ...entry.storedConfig },
-      createdWorkdir: entry.createdWorkdir,
-    });
-
-    return { sessionId: agent.sessionId };
   }
 
   private getConfiguredModels(sessionId?: string): {
     models: string[];
     currentModel: string | undefined;
   } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return {
       models: entry.agent.getConfiguredModels(),
       currentModel: entry.agent.getModelConfig().model,
@@ -956,7 +1107,7 @@ export class AgentBridge {
 
   private async setModel(model: string, sessionId?: string): Promise<null> {
     const entry = this.requireSession(sessionId);
-    entry.agent.setModel(model);
+    await entry.agent.setModel(model);
     // Keep storedConfig in sync: updateConfig recreates the agent from
     // storedConfig, so without this a later config save would revert the
     // model chosen here.
@@ -964,6 +1115,47 @@ export class AgentBridge {
     return null;
   }
 
+  // ── User preferences ──────────────────────────────────────────
+
+  /**
+   * 设置页保存路径：写用户级 `~/.wave/settings.json` 后，**显式重载本进程内
+   * 全部会话**的实时配置。
+   *
+   * 不能只依赖文件监视：会话启动时该文件（乃至 `~/.wave` 目录）通常还不存在，
+   * 监视要靠在父目录链存在的前提下补发事件；而这个文件正是被本次保存**创建**
+   * 出来的最常见场景（全新安装的第一次保存，spec core/agent-config.md
+   * 「设置实时重载」场景 7）。写完即重载使「保存 ⇒ 下一轮生效」与监视是否就绪
+   * 无关；监视若也命中，重载是幂等的（并发重载按 `reloadInProgress` 去重）。
+   *
+   * 空载荷（无差异保存、只回读）不落盘，也不重载。
+   *
+   * 回包是**生效视图**（同 `getUserSettings`）：设置页在保存后仍须看到「被组织
+   * 配置覆盖」的键的生效值与来源，而不是回退成用户文件里的值。
+   */
+  private async updateUserSettings(
+    patch: UserPreferenceSettings,
+  ): Promise<UserPreferenceSettingsView> {
+    await updateUserPreferenceSettings(patch);
+    if (!Object.values(patch).every((value) => value === undefined)) {
+      await Promise.all(
+        [...this.sessions.values()].map((entry) =>
+          entry.agent.reloadConfiguration(),
+        ),
+      );
+    }
+    return this.userSettingsView();
+  }
+
+  /**
+   * 用户偏好的**生效视图**：生效值 + 每键来源层（用户级文件 / Remote 组织下发 /
+   * 机器环境变量 / 默认）。设置页据此把「由组织配置管理」的键显示为生效值 +
+   * 置灰（spec core/agent-config.md 边界说明「用户偏好的层与来源」）。
+   */
+  private userSettingsView(): UserPreferenceSettingsView {
+    const { values, sources } = readUserPreferenceView();
+    return { ...values, preferenceSources: sources };
+  }
+
   // ── Messages ──────────────────────────────────────────────────
 
   private async sendMessage(
@@ -1104,7 +1296,7 @@ export class AgentBridge {
   private async listRewindCheckpoints(sessionId?: string): Promise<{
     checkpoints: Array<{ id: string; content: string }>;
   }> {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     const { messages } = await entry.agent.getFullMessageThread();
     // 压缩 append-only 后同 id 消息在磁盘完整线程中重复出现（压缩前历史 +
     // 压缩后 append 的重复）。按 id 去重并保留最后一次出现（与折叠后的
@@ -1151,7 +1343,7 @@ export class AgentBridge {
     messages: Message[];
     contextUsagePercent?: number;
   } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return {
       messages: entry.agent.displayMessages,
       contextUsagePercent: this.contextUsagePercentOf(entry.agent),
@@ -1162,7 +1354,7 @@ export class AgentBridge {
     messages: Message[];
     sessionIds: string[];
   }> {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return entry.agent.getFullMessageThread();
   }
 
@@ -1181,7 +1373,7 @@ export class AgentBridge {
     taskId: string,
     sessionId?: string,
   ): { output: ReturnType<Agent["getBackgroundTaskOutput"]> } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return { output: entry.agent.getBackgroundTaskOutput(taskId) };
   }
 
@@ -1203,7 +1395,7 @@ export class AgentBridge {
   private async getWorkflowRuns(
     sessionId?: string,
   ): Promise<{ runs: SerializableWorkflowRun[] }> {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     const runs = await entry.agent.getWorkflowRuns();
     return {
       runs: runs.map((r) => {
@@ -1235,7 +1427,7 @@ export class AgentBridge {
   }
 
   private getPermissionMode(sessionId?: string): { mode: PermissionMode } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return { mode: entry.agent.getPermissionMode() };
   }
 
@@ -1249,7 +1441,7 @@ export class AgentBridge {
     path: string | null;
     content: string | null;
   }> {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     const agent = entry.agent;
     const planPath =
       agent.getPlanFilePath() ?? (await agent.awaitPlanFilePath());
@@ -1268,7 +1460,7 @@ export class AgentBridge {
   // ── MCP ───────────────────────────────────────────────────────
 
   private getMcpServers(sessionId?: string): { servers: McpServerStatus[] } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return { servers: entry.agent.getMcpServers() };
   }
 
@@ -1304,7 +1496,7 @@ export class AgentBridge {
     userPath: string | null;
     projectPath: string | null;
   } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return {
       userPath: entry.agent.getUserMcpConfigPath(),
       projectPath: entry.agent.getProjectMcpConfigPath(),
@@ -1314,19 +1506,19 @@ export class AgentBridge {
   // ── Commands ──────────────────────────────────────────────────
 
   private getSlashCommands(sessionId?: string): { commands: SlashCommand[] } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return { commands: entry.agent.getSlashCommands() };
   }
 
   private getSubagentConfigurations(sessionId?: string): {
     configurations: SubagentConfiguration[];
   } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return { configurations: entry.agent.getSubagentConfigurations() };
   }
 
   private getSkillMetadata(sessionId?: string): { skills: SkillMetadata[] } {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     return { skills: entry.agent.getSkillMetadata() };
   }
 
@@ -1355,7 +1547,7 @@ export class AgentBridge {
     hooks: Partial<Record<string, unknown[]>>;
     configPath: string | null;
   }> {
-    const entry = this.requireSession(sessionId);
+    const entry = this.requireSessionForRead(sessionId);
     const hooks = await entry.agent.getHooksByScope(scope);
     // 回带该 scope 钩子所在 settings.json 的绝对路径（宿主 GUI 打开文件用；
     // plugin 钩子来自代码而非配置文件 → null）。
@@ -1492,12 +1684,31 @@ export class AgentBridge {
   /** Daemon list: expose the in-memory session registry (live sessions only,
    * not disk-scanning). Registration order is preserved. The working directory
    * shown is the session's recorded creation workdir (stable identity), not the
-   * live value that drifts with in-session `cd`. */
+   * live value that drifts with in-session `cd`.
+   *
+   * A session mid-rebuild (`transitioning`, see `SessionEntry`) reports
+   * `isLoading: true`: its outgoing agent has already been aborted by the
+   * teardown, so its own flag reads false while the replacement is still being
+   * built — reporting that would hand a `wait` the "listed + not busy"
+   * combination it settles on. "Not idle" is the honest reading of "this session
+   * has no agent right now", and it can only make a waiter wait.
+   *
+   * `hasRunningBackgroundWork` / `hasPendingMessages` are the other two halves of
+   * the idle predicate `wait` / `status` share with `wave -p` (print mode): a
+   * session whose foreground turn has ended can still own a running background
+   * bash task or subagent, and the last such task flips to `completed` before its
+   * completion notification is enqueued for the main agent's follow-up turn —
+   * reading only `isLoading` reports "done" in both cases. They are read from the
+   * live agent here rather than tracked separately, and mirror it as-is: the
+   * rebuild window above is already covered by `isLoading`, so there is no need
+   * to also claim a `transitioning` session owns background work it doesn't. */
   private listDaemonSessions(): {
     sessions: Array<{
       sessionId: string;
       workingDirectory: string;
       isLoading: boolean;
+      hasRunningBackgroundWork: boolean;
+      hasPendingMessages: boolean;
       messageCount: number;
     }>;
   } {
@@ -1505,7 +1716,9 @@ export class AgentBridge {
       sessions: [...this.sessions.entries()].map(([sessionId, entry]) => ({
         sessionId,
         workingDirectory: entry.createdWorkdir,
-        isLoading: entry.agent.isLoading,
+        isLoading: entry.transitioning === true || entry.agent.isLoading,
+        hasRunningBackgroundWork: entry.agent.hasRunningBackgroundWork,
+        hasPendingMessages: entry.agent.hasPendingMessages,
         messageCount: entry.agent.displayMessages.length,
       })),
     };
@@ -1528,7 +1741,12 @@ export class AgentBridge {
   }
 
   private async getAccountInfo(): Promise<{
-    plan?: { monthlyQuota: number; months: number; used: number } | null;
+    /**
+     * 计费结论（套餐两根条 + 到期日 + 降级原因），形状见 codechat `GET /api/v1/account` → `billing`
+     * （判定出自与 proxy 扣费同一份代码）。本层只转发、不解析；具体形状由 wave-webview-fixtures
+     * 的 AccountBillingInfo 在宿主/卡片侧约束。
+     */
+    billing?: unknown;
     apiQuota?: { limit: number | null; used: number } | null;
   }> {
     const authService = AuthService.getInstance();
@@ -1547,7 +1765,7 @@ export class AgentBridge {
       throw new Error(`Account query failed (${response.status})`);
     }
     return (await response.json()) as {
-      plan?: { monthlyQuota: number; months: number; used: number } | null;
+      billing?: unknown;
       apiQuota?: { limit: number | null; used: number } | null;
     };
   }
@@ -1678,6 +1896,7 @@ export class AgentBridge {
           marketplace: p.marketplace,
           installed: p.installed,
           version: p.version,
+          latestVersion: p.latestVersion,
           enabled: mergedEnabled[pluginId] !== false,
           scope: p.scope,
         };
@@ -1699,10 +1918,14 @@ export class AgentBridge {
 
   private async uninstallPlugin(
     pluginId: string,
+    scope?: Scope,
     workdir?: string,
     sessionId?: string,
   ) {
-    await this.getPluginCore(workdir, sessionId).uninstallPlugin(pluginId);
+    await this.getPluginCore(workdir, sessionId).uninstallPlugin(
+      pluginId,
+      scope,
+    );
     return null;
   }
 
@@ -1727,6 +1950,21 @@ export class AgentBridge {
     );
   }
 
+  /**
+   * `/reload-plugins`：把磁盘上的插件状态就地换装进**本进程内全部活跃会话**
+   * （spec ecosystem/plugin.md「插件变更的就地重载」）。不重建会话、sessionId
+   * 不变；没有活跃会话时也返回成功——新会话创建时会按磁盘状态自然装载。
+   *
+   * 每个会话读的是同一份磁盘状态，因此取任一份结果汇报即可（各会话的差异只体现
+   * 在各自注册表的可见性上）。失败不回滚，原样回传给宿主提示。
+   */
+  private async reloadPlugins(): Promise<PluginReloadResult> {
+    const results = await Promise.all(
+      [...this.sessions.values()].map((entry) => entry.agent.reloadPlugins()),
+    );
+    return results[0] ?? { plugins: [], failures: [] };
+  }
+
   private async getProjectSettings(
     workdir?: string,
     sessionId?: string,
@@ -1839,10 +2077,36 @@ export class AgentBridge {
     return this.getPluginCore(workdir, sessionId).updatePlugin(pluginId);
   }
 
+  /**
+   * 更换已安装插件的安装作用域（设置页插件市场）：清掉各作用域的启用记录后
+   * 在目标作用域启用，因此旧作用域不再保留该插件。
+   */
+  private async setPluginScope(
+    pluginId: string,
+    scope: Scope,
+    workdir?: string,
+    sessionId?: string,
+  ) {
+    return this.getPluginCore(workdir, sessionId).setPluginScope(
+      pluginId,
+      scope,
+    );
+  }
+
   private async listMarketplaces(workdir?: string, sessionId?: string) {
     return this.getPluginCore(workdir, sessionId).listMarketplaces();
   }
 
+  /**
+   * 刷新各已注册市场的检出（不装插件），供「打开插件市场界面」时后台调用
+   * （spec 插件市场 A-013 场景 5）。市场级错误在 SDK 内静默记录，宿主侧失败
+   * 也不打断界面（场景 9）。
+   */
+  private async refreshMarketplaces(workdir?: string, sessionId?: string) {
+    await this.getPluginCore(workdir, sessionId).refreshMarketplaces();
+    return null;
+  }
+
   private async addMarketplace(
     input: string,
     scope?: Scope,
@@ -1867,8 +2131,16 @@ export class AgentBridge {
     workdir?: string,
     sessionId?: string,
   ) {
-    await this.getPluginCore(workdir, sessionId).updateMarketplace(name);
-    return null;
+    // 这个通道只服务 GUI 的「批量更新插件」按钮：按当前清单升级、不拉检出
+    // （清单刷新由打开视图时的 refreshMarketplaces 承担，spec 插件市场 A-013/
+    // 场景 14）。
+    const updated = await this.getPluginCore(
+      workdir,
+      sessionId,
+    ).updateMarketplacePlugins(name);
+    // 实际升级的插件数回给宿主：0 = 该市场已是最新（宿主据此提示，
+    // spec 插件市场场景 13）。
+    return { updated };
   }
 
   // ── Callbacks → Notifications ─────────────────────────────────
@@ -2042,6 +2314,9 @@ export class AgentBridge {
           ctx.registeredSessionId,
         );
       },
+      onPlanFileUpdated: (content: string) => {
+        this.emit("planFileUpdated", { content }, ctx.registeredSessionId);
+      },
     };
   }
 
@@ -2052,7 +2327,34 @@ export class AgentBridge {
 
   // ── Utils ─────────────────────────────────────────────────────
 
+  /**
+   * The session entry for a request that CHANGES session state. A session whose
+   * agent is mid-rebuild (`updateConfig` → `SessionEntry.transitioning`) has no
+   * usable agent: its outgoing one is being torn down, so a message injected into
+   * it would be lost and a config write would be overwritten by the rebuild's own
+   * stored config. Those requests are refused with a retryable error instead.
+   * Read-only requests use `requireSessionForRead` and stay available.
+   */
   private requireSession(sessionId?: string): SessionEntry {
+    const entry = this.requireSessionForRead(sessionId);
+    if (entry.transitioning) {
+      throw new RpcError(
+        PROTOCOL_INTERNAL_ERROR,
+        `Session ${sessionId} is being reconfigured (config reload in progress), retry shortly`,
+      );
+    }
+    return entry;
+  }
+
+  /**
+   * The session entry for a request that only READS. During a rebuild the entry
+   * holds the outgoing agent: its messages are this same session's transcript and
+   * its config is the pre-reload one, both of which are the best answer available
+   * for the few hundred milliseconds the rebuild takes. Refusing reads instead
+   * would turn a config reload into a burst of errors in whatever host happens to
+   * be polling (`getMcpServers`, `getSlashCommands`, …).
+   */
+  private requireSessionForRead(sessionId?: string): SessionEntry {
     if (!sessionId) {
       throw new RpcError(
         PROTOCOL_INTERNAL_ERROR,