wave-code 1.1.4 → 1.2.0

package/src/stdio/agentBridge.ts

@@ -31,7 +31,10 @@ import {
   type QueuedMessage,
   type SessionMetadata,
   type McpServerConfig,
+  type McpConfig,
   type Scope,
+  type PartialHookConfiguration,
+  isValidHookEvent,
   listSessions,
   searchFiles,
   generateRandomName,
@@ -43,6 +46,9 @@ import {
   validateWorktreeRemovalPath,
   type SlashCommand,
   loadUserConfigEnv,
+  loadWaveConfigFromFile,
+  getUserConfigPaths,
+  getProjectConfigPaths,
   type SubagentConfiguration,
   type SkillMetadata,
 } from "wave-agent-sdk";
@@ -53,10 +59,15 @@ import {
   METHOD_NOT_FOUND as PROTOCOL_METHOD_NOT_FOUND,
 } from "./protocol.js";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, existsSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, extname, join } from "node:path";
-import { createWorktree, removeWorktree } from "../utils/worktree.js";
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir, open, readFile, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, extname, join } from "node:path";
+import {
+  createWorktree,
+  getWorktreeChanges,
+  removeWorktree,
+} from "../utils/worktree.js";
 import { logger } from "../utils/logger.js";
 import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
 
@@ -68,6 +79,11 @@ export type NotificationEmitter = (
 
 export interface AgentBridgeOptions {
   emit: NotificationEmitter;
+  /** Daemon transport only (`wave daemon stop`/`restart`): invoked by the
+   * `shutdown` RPC after every session has been destroyed — the server tears
+   * down its socket and exits. stdio mode leaves it unset, so `shutdown` is
+   * "Method not found" there. */
+  onShutdownRequest?: () => void;
 }
 
 interface InitializeParams {
@@ -88,6 +104,9 @@ interface InitializeParams {
   mcpServers?: Record<string, McpServerConfig>;
   worktreeName?: string;
   isNewWorktree?: boolean;
+  /** Settings-page auto-memory toggle/frequency (session-level override). */
+  autoMemoryEnabled?: boolean;
+  autoMemoryFrequency?: number;
 }
 
 interface UpdateConfigParams {
@@ -98,6 +117,9 @@ interface UpdateConfigParams {
   model?: string;
   fastModel?: string;
   language?: string;
+  /** Settings-page auto-memory toggle/frequency (session-level override). */
+  autoMemoryEnabled?: boolean;
+  autoMemoryFrequency?: number;
 }
 
 interface SearchFilesParams {
@@ -109,6 +131,16 @@ interface SearchFilesParams {
 interface SessionEntry {
   agent: Agent;
   storedConfig: Partial<InitializeParams>;
+  /**
+   * The workdir the session was CREATED in — an immutable identity, unlike the
+   * live `agent.workingDirectory`, which drifts as the session `cd`s (bash tool
+   * / worktree switches). Hosted-session consumers (destroy --remove-worktree's
+   * worktree resolution, list) read this instead of the live value so a session
+   * that moved out of its worktree into the main repo is still cleaned up at
+   * the right place. Recovered from the transcript's creation-time metadata
+   * header when the session is re-attached from disk after a daemon restart.
+   */
+  createdWorkdir: string;
 }
 
 /**
@@ -138,11 +170,13 @@ export class AgentBridge {
   >();
   private permissionCounter = 0;
   private emit: NotificationEmitter;
+  private onShutdownRequest: (() => void) | undefined;
   private pluginCore: PluginCore | undefined;
   private pluginCoreWorkdir: string | undefined;
 
   constructor(options: AgentBridgeOptions) {
     this.emit = options.emit;
+    this.onShutdownRequest = options.onShutdownRequest;
     // Mirror the user-level settings env WAVE_SERVER_URL into process.env
     // before any agent initializes. getAuthStatus (webviewReady →
     // pushInitialState) can run before the first agent, and AuthService falls
@@ -178,6 +212,20 @@ export class AgentBridge {
         return this.listPendingPermissions();
       case "listDaemonSessions":
         return this.listDaemonSessions();
+      case "shutdown":
+        // Daemon-level graceful exit (`wave daemon stop` / `restart`): destroy
+        // every session first (each agent saves its transcript and drains
+        // auto-memory), then hand the process exit to the transport owner.
+        // Only the daemon registers the hook — stdio has no such concept.
+        if (!this.onShutdownRequest) {
+          throw new RpcError(
+            PROTOCOL_METHOD_NOT_FOUND,
+            "Method not found: shutdown",
+          );
+        }
+        await this.destroyAll();
+        this.onShutdownRequest();
+        return null;
       case "updateConfig":
         return this.updateConfig(p as unknown as UpdateConfigParams, sessionId);
       case "getConfiguredModels":
@@ -228,6 +276,8 @@ export class AgentBridge {
         return this.setPermissionMode(p.mode as PermissionMode, sessionId);
       case "getPermissionMode":
         return this.getPermissionMode(sessionId);
+      case "getPlanFile":
+        return this.getPlanFile(sessionId);
 
       // ── MCP ──
       case "getMcpServers":
@@ -236,6 +286,14 @@ export class AgentBridge {
         return this.connectMcpServer(p.serverName as string, sessionId);
       case "disconnectMcpServer":
         return this.disconnectMcpServer(p.serverName as string, sessionId);
+      case "removeMcpServer":
+        return this.removeMcpServer(
+          p.scope as "user" | "project",
+          p.serverName as string,
+          sessionId,
+        );
+      case "getMcpConfigPaths":
+        return this.getMcpConfigPaths(sessionId);
 
       // ── Commands ──
       case "getSlashCommands":
@@ -244,6 +302,21 @@ export class AgentBridge {
         return this.getSubagentConfigurations(sessionId);
       case "getSkillMetadata":
         return this.getSkillMetadata(sessionId);
+      case "deleteSkill":
+        return this.deleteSkill(p.name as string, sessionId);
+      case "deleteSubagent":
+        return this.deleteSubagent(p.name as string, sessionId);
+      case "getHooksByScope":
+        return this.getHooksByScope(
+          p.scope as "user" | "project" | "plugin",
+          sessionId,
+        );
+      case "deleteHook":
+        return this.deleteHook(
+          p.scope as "user" | "project",
+          p.hookName as string,
+          sessionId,
+        );
 
       // ── File / History (global — no session required) ──
       case "searchFiles":
@@ -267,11 +340,29 @@ export class AgentBridge {
       // ── Auth (global — no session required) ──
       case "getAuthStatus":
         return this.getAuthStatus();
+      case "getAccountInfo":
+        return this.getAccountInfo();
       case "login":
         return this.login(p.serverUrl as string | undefined);
       case "logout":
         return this.logout();
 
+      // ── Memory files (settings UI — user-level ~/.wave/AGENTS.md and
+      //    project-level <workdir>/AGENTS.md) ──
+      case "getAgentsContent":
+        return this.getAgentsContent(
+          p.scope as "user" | "project",
+          p.workdir as string | undefined,
+          sessionId,
+        );
+      case "setAgentsContent":
+        return this.setAgentsContent(
+          p.scope as "user" | "project",
+          p.content as string,
+          p.workdir as string | undefined,
+          sessionId,
+        );
+
       // ── Plugins (global — no session required) ──
       case "listPlugins":
         return this.listPlugins(p.workdir as string | undefined, sessionId);
@@ -307,6 +398,18 @@ export class AgentBridge {
           p.workdir as string | undefined,
           sessionId,
         );
+      case "getHooksConfig":
+        return this.getHooksConfig(
+          p.scope as "user" | "project" | undefined,
+          p.workdir as string | undefined,
+          sessionId,
+        );
+      case "getMcpConfig":
+        return this.getMcpConfig(
+          p.scope as "user" | "project" | undefined,
+          p.workdir as string | undefined,
+          sessionId,
+        );
       case "setBuiltinPluginEnabled":
         return this.setBuiltinPluginEnabled(
           p.pluginId as string,
@@ -376,6 +479,10 @@ export class AgentBridge {
             name?: string;
           },
         );
+      case "getWorktreeChanges":
+        return this.getWorktreeChanges(
+          p as unknown as { path?: string; baseBranch?: string },
+        );
       case "removeWorktree":
         return this.removeWorktreeSession(
           p as unknown as {
@@ -446,6 +553,8 @@ export class AgentBridge {
       model: params.model,
       fastModel: params.fastModel,
       language: params.language,
+      autoMemoryEnabled: params.autoMemoryEnabled,
+      autoMemoryFrequency: params.autoMemoryFrequency,
       permissionMode: params.permissionMode,
       tools: params.tools,
       allowedTools: params.allowedTools,
@@ -462,9 +571,29 @@ export class AgentBridge {
     ctx.agent = agent;
     ctx.registeredSessionId = agent.sessionId;
 
+    // Record where the session was created (see SessionEntry.createdWorkdir).
+    // A fresh session's initialize workdir IS the creation dir. A from-disk
+    // re-attach (the daemon was restarted — killed / CLI 升级重启 / reboot —
+    // then status/send re-hosts the session) instead passes the re-attaching
+    // client's cwd — the transcript header (`{"type":"metadata","workdir":...}`, append-only since session
+    // creation) restores the original value when the agent's transcript is
+    // readable; otherwise the client cwd is the best available anchor.
+    let createdWorkdir: string;
+    if (params.restoreSessionId) {
+      createdWorkdir =
+        (await readTranscriptWorkdir(agent.sessionFilePath)) ??
+        params.workdir ??
+        agent.workingDirectory;
+    } else {
+      createdWorkdir = params.workdir ?? agent.workingDirectory;
+    }
+
     this.sessions.set(agent.sessionId, {
       agent,
-      storedConfig: { ...params },
+      // Keep storedConfig.workdir in sync: updateConfig rebuilds the agent from
+      // storedConfig, so the rebuild must stay anchored on the creation dir too.
+      storedConfig: { ...params, workdir: createdWorkdir },
+      createdWorkdir,
     });
 
     return {
@@ -486,27 +615,6 @@ export class AgentBridge {
     return null;
   }
 
-  /**
-   * True when every hosted session has settled: not generating, nothing queued,
-   * and no background work (background bash / subagents / workflows) — the same
-   * condition `wave -p` waits on before exiting (print-cli.ts). Pending
-   * permission approvals keep the owning agent's isLoading true, so they are
-   * covered without an explicit check.
-   */
-  public isIdle(): boolean {
-    for (const entry of this.sessions.values()) {
-      const agent = entry.agent;
-      if (
-        agent.isLoading ||
-        agent.hasPendingMessages ||
-        agent.hasRunningBackgroundWork
-      ) {
-        return false;
-      }
-    }
-    return true;
-  }
-
   /**
    * Destroy every hosted session agent. Each Agent.destroy() saves its
    * transcript, drains in-flight auto-memory extraction, and cleans up
@@ -533,7 +641,7 @@ export class AgentBridge {
     if (entry.agent.sessionId === restoreId) {
       this.emit(
         "messagesChange",
-        { messages: entry.agent.messages },
+        { messages: entry.agent.displayMessages },
         entry.agent.sessionId,
       );
       // The re-attached client also missed the loading state that settled
@@ -548,12 +656,57 @@ export class AgentBridge {
         },
         entry.agent.sessionId,
       );
+      // Same story for the context-usage indicator: the SDK's restore-time
+      // onLatestTotalTokensChange fired inside initialize — before this
+      // client's router registered — so replay the current usage or the
+      // webview keeps the previous session's (or no) percentage until the
+      // next turn pushes a fresh value (spec desktop-app 上下文用量指示器
+      // 场景 6: 恢复即显示该会话上次用量).
+      this.emitContextUsage(entry.agent);
       return null;
     }
     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
+    // conversation whose persisted total equals the agent's current one
+    // suppresses the change-push and the webview — which cleared the previous
+    // session's number on the switch — keeps a blank ring until the next turn
+    // (the change-push, when it does fire inside restoreSession, already
+    // delivered the same value; re-emitting is idempotent).
+    this.emitContextUsage(entry.agent);
     return null;
   }
 
+  /**
+   * Push the session's current context-usage percentage to the client. Shared
+   * by every restore path so a conversation the client just switched to always
+   * shows its usage right away instead of waiting for the next token change
+   * (spec desktop-app 上下文用量指示器 场景 6). A zero total means no real
+   * usage to report; the host keeps the empty ring until the first push.
+   */
+  private emitContextUsage(agent: Agent): void {
+    const percent = this.contextUsagePercentOf(agent);
+    if (percent !== undefined) {
+      this.emit("contextUsage", { percent }, agent.sessionId);
+    }
+  }
+
+  /**
+   * Current context-usage percentage of a session, or undefined when there is
+   * nothing to report yet (no tokens) or the model exposes no limit. Shared by
+   * the change-driven push and the getMessages response, so a host whose
+   * webview was re-created long after the last token change can still restore
+   * the ring without a per-host cache.
+   */
+  private contextUsagePercentOf(agent: Agent): number | undefined {
+    const tokens = agent.latestTotalTokens;
+    const max = agent.getMaxInputTokens();
+    if (tokens > 0 && max > 0) {
+      return Math.min(100, Math.round((tokens / max) * 100));
+    }
+    return undefined;
+  }
+
   private async listSessions(
     workdir?: string,
     sessionId?: string,
@@ -647,6 +800,21 @@ export class AgentBridge {
     }
   }
 
+  /**
+   * What a worktree deletion would throw away (uncommitted files and commits
+   * not on the base branch), so the caller can warn before deleting. Returns
+   * null when the worktree cannot be inspected.
+   */
+  private async getWorktreeChanges(params: {
+    path?: string;
+    baseBranch?: string;
+  }): Promise<{ files: number; commits: number } | null> {
+    if (!params.path) {
+      throw new RpcError(PROTOCOL_INTERNAL_ERROR, "path is required");
+    }
+    return getWorktreeChanges(params.path, params.baseBranch);
+  }
+
   private async removeWorktreeSession(params: {
     path: string;
     branch: string;
@@ -692,7 +860,10 @@ export class AgentBridge {
     const entry = this.requireSession(sessionId);
     return {
       sessionId: entry.agent.sessionId,
-      workingDirectory: entry.agent.workingDirectory,
+      // The recorded creation workdir, not the live agent.workingDirectory:
+      // destroy --remove-worktree resolves the session's worktree from this
+      // value, and it must not drift when the session cd'd out of the worktree.
+      workingDirectory: entry.createdWorkdir,
       latestTotalTokens: entry.agent.latestTotalTokens,
       permissionMode: entry.agent.getPermissionMode(),
       availableTools: entry.agent.getAvailableToolNames(),
@@ -723,6 +894,8 @@ export class AgentBridge {
       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,
@@ -764,6 +937,7 @@ export class AgentBridge {
     this.sessions.set(agent.sessionId, {
       agent,
       storedConfig: { ...entry.storedConfig },
+      createdWorkdir: entry.createdWorkdir,
     });
 
     return { sessionId: agent.sessionId };
@@ -973,9 +1147,15 @@ export class AgentBridge {
     return null;
   }
 
-  private getMessages(sessionId?: string): { messages: Message[] } {
+  private getMessages(sessionId?: string): {
+    messages: Message[];
+    contextUsagePercent?: number;
+  } {
     const entry = this.requireSession(sessionId);
-    return { messages: entry.agent.messages };
+    return {
+      messages: entry.agent.displayMessages,
+      contextUsagePercent: this.contextUsagePercentOf(entry.agent),
+    };
   }
 
   private async getFullMessageThread(sessionId?: string): Promise<{
@@ -1059,6 +1239,32 @@ export class AgentBridge {
     return { mode: entry.agent.getPermissionMode() };
   }
 
+  /**
+   * Returns the current plan file path and its contents for the session.
+   * When the path generation is still in flight (e.g. the host just switched
+   * to plan mode via setPermissionMode), awaits it so the caller can read the
+   * plan before triggering a query (the plan mode reminder needs the path).
+   */
+  private async getPlanFile(sessionId?: string): Promise<{
+    path: string | null;
+    content: string | null;
+  }> {
+    const entry = this.requireSession(sessionId);
+    const agent = entry.agent;
+    const planPath =
+      agent.getPlanFilePath() ?? (await agent.awaitPlanFilePath());
+    if (!planPath) {
+      return { path: null, content: null };
+    }
+    try {
+      const content = await readFile(planPath, "utf8");
+      return { path: planPath, content };
+    } catch (error) {
+      logger?.warn("Failed to read plan file", error);
+      return { path: planPath, content: null };
+    }
+  }
+
   // ── MCP ───────────────────────────────────────────────────────
 
   private getMcpServers(sessionId?: string): { servers: McpServerStatus[] } {
@@ -1084,6 +1290,27 @@ export class AgentBridge {
     return { success };
   }
 
+  private async removeMcpServer(
+    scope: "user" | "project",
+    serverName: string,
+    sessionId?: string,
+  ): Promise<{ success: boolean }> {
+    const entry = this.requireSession(sessionId);
+    const success = await entry.agent.removeMcpServer(scope, serverName);
+    return { success };
+  }
+
+  private getMcpConfigPaths(sessionId?: string): {
+    userPath: string | null;
+    projectPath: string | null;
+  } {
+    const entry = this.requireSession(sessionId);
+    return {
+      userPath: entry.agent.getUserMcpConfigPath(),
+      projectPath: entry.agent.getProjectMcpConfigPath(),
+    };
+  }
+
   // ── Commands ──────────────────────────────────────────────────
 
   private getSlashCommands(sessionId?: string): { commands: SlashCommand[] } {
@@ -1103,6 +1330,50 @@ export class AgentBridge {
     return { skills: entry.agent.getSkillMetadata() };
   }
 
+  private async deleteSkill(
+    name: string,
+    sessionId?: string,
+  ): Promise<{ success: boolean }> {
+    const entry = this.requireSession(sessionId);
+    const success = await entry.agent.deleteSkill(name);
+    return { success };
+  }
+
+  private async deleteSubagent(
+    name: string,
+    sessionId?: string,
+  ): Promise<{ success: boolean }> {
+    const entry = this.requireSession(sessionId);
+    const success = await entry.agent.deleteSubagent(name);
+    return { success };
+  }
+
+  private async getHooksByScope(
+    scope: "user" | "project" | "plugin",
+    sessionId?: string,
+  ): Promise<{
+    hooks: Partial<Record<string, unknown[]>>;
+    configPath: string | null;
+  }> {
+    const entry = this.requireSession(sessionId);
+    const hooks = await entry.agent.getHooksByScope(scope);
+    // 回带该 scope 钩子所在 settings.json 的绝对路径（宿主 GUI 打开文件用；
+    // plugin 钩子来自代码而非配置文件 → null）。
+    const configPath =
+      scope === "plugin" ? null : entry.agent.getHookConfigPath(scope);
+    return { hooks, configPath };
+  }
+
+  private async deleteHook(
+    scope: "user" | "project",
+    hookName: string,
+    sessionId?: string,
+  ): Promise<{ success: boolean }> {
+    const entry = this.requireSession(sessionId);
+    await entry.agent.deleteHook(scope, hookName);
+    return { success: true };
+  }
+
   // ── File / History (global) ───────────────────────────────────
 
   private async searchFiles(
@@ -1219,7 +1490,9 @@ export class AgentBridge {
   }
 
   /** Daemon list: expose the in-memory session registry (live sessions only,
-   * not disk-scanning). Registration order is preserved. */
+   * 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`. */
   private listDaemonSessions(): {
     sessions: Array<{
       sessionId: string;
@@ -1231,9 +1504,9 @@ export class AgentBridge {
     return {
       sessions: [...this.sessions.entries()].map(([sessionId, entry]) => ({
         sessionId,
-        workingDirectory: entry.agent.workingDirectory,
+        workingDirectory: entry.createdWorkdir,
         isLoading: entry.agent.isLoading,
-        messageCount: entry.agent.messages.length,
+        messageCount: entry.agent.displayMessages.length,
       })),
     };
   }
@@ -1254,6 +1527,31 @@ export class AgentBridge {
     };
   }
 
+  private async getAccountInfo(): Promise<{
+    plan?: { monthlyQuota: number; months: number; used: number } | null;
+    apiQuota?: { limit: number | null; used: number } | null;
+  }> {
+    const authService = AuthService.getInstance();
+    await authService.checkAndRefreshTokenIfNeeded();
+    if (!authService.isSSOAuthenticated()) return {};
+    const token = authService.getSSOToken();
+    if (!token) return {};
+    const response = await fetch(
+      `${authService.getServerUrl()}/api/v1/account`,
+      {
+        headers: { Authorization: `Bearer ${token}` },
+      },
+    );
+    if (!response.ok) {
+      // 401 / 5xx — 让调用方（desktop host）保留上次成功数据（spec 场景 9）。
+      throw new Error(`Account query failed (${response.status})`);
+    }
+    return (await response.json()) as {
+      plan?: { monthlyQuota: number; months: number; used: number } | null;
+      apiQuota?: { limit: number | null; used: number } | null;
+    };
+  }
+
   private async login(
     serverUrl?: string,
   ): Promise<{ user: { id: string; email?: string } | undefined }> {
@@ -1273,6 +1571,88 @@ export class AgentBridge {
     return null;
   }
 
+  // ── Memory files (settings UI) ───────────────────────────────
+
+  /**
+   * Read an AGENTS.md file for the settings UI: user-level reads
+   * ~/.wave/AGENTS.md, project-level reads <workdir>/AGENTS.md. Prefers the
+   * live agent (clears its caches on write) and falls back to direct file
+   * access when no session is bound (e.g. desktop before any session exists).
+   */
+  private async getAgentsContent(
+    scope: "user" | "project",
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ content: string; path?: string }> {
+    const agent = this.sessions.get(sessionId ?? "")?.agent;
+    if (scope === "user") {
+      if (agent) {
+        return { content: await agent.readUserMemoryContent() };
+      }
+      const path = this.getUserMemoryFilePath();
+      return { content: await readTextFileSafe(path), path };
+    }
+    const resolvedWorkdir =
+      workdir || (agent?.workingDirectory as string | undefined);
+    if (!resolvedWorkdir) {
+      throw new RpcError(
+        PROTOCOL_INVALID_PARAMS,
+        "Project-scope AGENTS.md requires a workdir",
+      );
+    }
+    if (agent) {
+      return {
+        content: await agent.readProjectMemoryContent(resolvedWorkdir),
+      };
+    }
+    const path = join(resolvedWorkdir, "AGENTS.md");
+    return { content: await readTextFileSafe(path), path };
+  }
+
+  /**
+   * Write an AGENTS.md file from the settings UI: user-level writes
+   * ~/.wave/AGENTS.md, project-level writes <workdir>/AGENTS.md. Goes through
+   * the live agent when available so its memory caches are invalidated.
+   */
+  private async setAgentsContent(
+    scope: "user" | "project",
+    content: string,
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ ok: boolean; path?: string }> {
+    const agent = this.sessions.get(sessionId ?? "")?.agent;
+    if (scope === "user") {
+      if (agent) {
+        await agent.writeUserMemoryContent(content);
+      } else {
+        const path = this.getUserMemoryFilePath();
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content, "utf-8");
+      }
+      return { ok: true };
+    }
+    const resolvedWorkdir =
+      workdir || (agent?.workingDirectory as string | undefined);
+    if (!resolvedWorkdir) {
+      throw new RpcError(
+        PROTOCOL_INVALID_PARAMS,
+        "Project-scope AGENTS.md requires a workdir",
+      );
+    }
+    if (agent) {
+      await agent.writeProjectMemoryContent(resolvedWorkdir, content);
+    } else {
+      const path = join(resolvedWorkdir, "AGENTS.md");
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, content, "utf-8");
+    }
+    return { ok: true };
+  }
+
+  private getUserMemoryFilePath(): string {
+    return join(homedir(), ".wave", "AGENTS.md");
+  }
+
   // ── Plugins (global) ─────────────────────────────────────────
 
   private getPluginCore(workdir?: string, sessionId?: string): PluginCore {
@@ -1359,6 +1739,81 @@ export class AgentBridge {
     };
   }
 
+  /**
+   * Read the hooks fragment from a single config scope (user or project), for
+   * the settings page read-only hooks view. Hooks come from settings.json
+   * (user: ~/.wave/settings.json; project: .wave/settings.json +
+   * settings.local.json merged, append per event).
+   */
+  private async getHooksConfig(
+    scope: "user" | "project" | undefined,
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ hooks: PartialHookConfiguration | undefined }> {
+    const resolvedScope = scope ?? "user";
+
+    if (resolvedScope === "user") {
+      const config = loadWaveConfigFromFile(getUserConfigPaths()[0]);
+      return { hooks: config?.hooks };
+    }
+
+    const resolvedWorkdir =
+      workdir || this.getSessionWorkdir(sessionId) || process.cwd();
+    const [localPath, jsonPath] = getProjectConfigPaths(resolvedWorkdir);
+    const hooks: PartialHookConfiguration = {};
+    for (const config of [
+      loadWaveConfigFromFile(jsonPath),
+      loadWaveConfigFromFile(localPath),
+    ]) {
+      if (!config?.hooks) continue;
+      for (const [event, eventConfigs] of Object.entries(config.hooks)) {
+        if (!isValidHookEvent(event)) continue;
+        hooks[event] = [...(hooks[event] ?? []), ...(eventConfigs ?? [])];
+      }
+    }
+    return { hooks: Object.keys(hooks).length > 0 ? hooks : undefined };
+  }
+
+  /**
+   * Read the mcpServers fragment from a single config scope (user or project),
+   * for the settings page read-only MCP view. MCP servers come from mcp.json
+   * (user: ~/.wave/mcp.json; project: <workdir>/.mcp.json). Runtime status
+   * (connect/disconnect/tools) is served by the existing getMcpServers RPC.
+   */
+  private async getMcpConfig(
+    scope: "user" | "project" | undefined,
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ mcpServers: Record<string, McpServerConfig> }> {
+    const resolvedScope = scope ?? "user";
+
+    if (resolvedScope === "user") {
+      return {
+        mcpServers: this.readMcpServersFile(
+          join(homedir(), ".wave", "mcp.json"),
+        ),
+      };
+    }
+
+    const resolvedWorkdir =
+      workdir || this.getSessionWorkdir(sessionId) || process.cwd();
+    return {
+      mcpServers: this.readMcpServersFile(join(resolvedWorkdir, ".mcp.json")),
+    };
+  }
+
+  private readMcpServersFile(
+    filePath: string,
+  ): Record<string, McpServerConfig> {
+    try {
+      if (!existsSync(filePath)) return {};
+      const raw = JSON.parse(readFileSync(filePath, "utf-8")) as McpConfig;
+      return raw.mcpServers ?? {};
+    } catch {
+      return {};
+    }
+  }
+
   private async setBuiltinPluginEnabled(
     pluginId: string,
     enabled: boolean,
@@ -1483,6 +1938,18 @@ export class AgentBridge {
           ctx.registeredSessionId,
         );
       },
+      onLatestTotalTokensChange: (tokens: number) => {
+        // Batch 2 压缩上下文 button: push the context usage percentage on
+        // every token-count change. The SDK fires this on each finished
+        // request (fresh total) and on session restore (the persisted total),
+        // so the webview button shows real usage without waiting for a turn —
+        // aligned with the CLI, which reads the same callback (spec 场景 5/6).
+        const max = ctx.agent?.getMaxInputTokens() ?? 0;
+        if (max > 0) {
+          const percent = Math.min(100, Math.round((tokens / max) * 100));
+          this.emit("contextUsage", { percent }, ctx.registeredSessionId);
+        }
+      },
       onCommandRunningChange: (running: boolean) => {
         this.emit("commandRunningChange", { running }, ctx.registeredSessionId);
       },
@@ -1542,29 +2009,8 @@ export class AgentBridge {
       onMcpServersChange: (servers: McpServerStatus[]) => {
         this.emit("mcpServersChange", { servers }, ctx.registeredSessionId);
       },
-      onAddBangMessage: (command, messageId) => {
-        this.emit(
-          "bangMessageAdded",
-          { command, messageId },
-          ctx.registeredSessionId,
-        );
-      },
-      onUpdateBangMessage: (command, output, messageId) => {
-        this.emit(
-          "bangMessageUpdated",
-          { command, output, messageId },
-          ctx.registeredSessionId,
-        );
-      },
-      onCompleteBangMessage: (command, exitCode, messageId, output) => {
-        this.emit(
-          "bangMessageCompleted",
-          { command, exitCode, messageId, output },
-          ctx.registeredSessionId,
-        );
-      },
       onNotificationMessageAdded: (params) => {
-        const msg = ctx.agent?.messages.find(
+        const msg = ctx.agent?.displayMessages.find(
           (m) =>
             m.role === "user" &&
             m.blocks.some(
@@ -1656,3 +2102,54 @@ function isSessionRecoveryError(error: unknown): boolean {
     message.startsWith("Session not found:")
   );
 }
+
+/** Read a text file, returning "" when it does not exist. */
+async function readTextFileSafe(filePath: string): Promise<string> {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+
+/**
+ * Read the creation-time workdir from a session transcript's metadata header —
+ * the first line `{"type":"metadata","workdir":...,"createdAt":...,"gitBranch":...}`
+ * the SDK writes once at session creation. The header is append-only, so it
+ * records where the session was created even after the live working directory
+ * drifted (in-session `cd`) or after a daemon restart re-anchored the agent at
+ * a client's cwd. Returns undefined when the file is missing, legacy (no
+ * header), or unreadable. Only the header line is read (transcripts can grow
+ * large); a 4KiB read covers any realistic header.
+ */
+async function readTranscriptWorkdir(
+  transcriptPath?: string,
+): Promise<string | undefined> {
+  if (!transcriptPath) return undefined;
+  try {
+    const handle = await open(transcriptPath, "r");
+    try {
+      const buffer = Buffer.alloc(4096);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+      if (bytesRead === 0) return undefined;
+      const newline = buffer.indexOf(0x0a);
+      const firstLine = buffer
+        .subarray(0, newline === -1 ? bytesRead : newline)
+        .toString("utf8");
+      const header = JSON.parse(firstLine) as {
+        type?: string;
+        workdir?: unknown;
+      };
+      return header.type === "metadata" && typeof header.workdir === "string"
+        ? header.workdir
+        : undefined;
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return undefined;
+  }
+}