wave-agent-sdk 1.2.0 → 1.3.0

package/dist/services/pluginLoader.d.ts

@@ -1,4 +1,4 @@
-import { PluginManifest, CustomSlashCommand, Skill, LspConfig, McpConfig, PartialHookConfiguration } from "../types/index.js";
+import { PluginManifest, CustomSlashCommand, Skill, LspConfig, McpConfig, McpServerConfig, PartialHookConfiguration } from "../types/index.js";
 import { type SubagentConfiguration } from "../utils/subagentParser.js";
 export declare class PluginLoader {
     /**
@@ -21,9 +21,17 @@ export declare class PluginLoader {
      */
     static loadLspConfig(pluginPath: string): Promise<LspConfig | undefined>;
     /**
-     * Load MCP configuration from a plugin
-     */
-    static loadMcpConfig(pluginPath: string): Promise<McpConfig | undefined>;
+     * Load MCP configuration from a plugin.
+     *
+     * Accepts both declaration shapes found in the wild (spec plugin A-023): the
+     * wrapped `{"mcpServers": {…}}` and the flat `{"<serverName>": {…}}`, matching
+     * Claude Code's `parsed.mcpServers || parsed`. A plugin manifest that declares
+     * `mcpServers` inline is equivalent to a sibling `.mcp.json`; when both exist
+     * they are merged by server name, the file winning.
+     *
+     * @param manifestMcpServers Inline declarations from the plugin manifest
+     */
+    static loadMcpConfig(pluginPath: string, manifestMcpServers?: Record<string, McpServerConfig>): Promise<McpConfig | undefined>;
     /**
      * Load hooks configuration from a plugin
      */

package/dist/services/pluginLoader.js

@@ -128,18 +128,33 @@ export class PluginLoader {
         }
     }
     /**
-     * Load MCP configuration from a plugin
+     * Load MCP configuration from a plugin.
+     *
+     * Accepts both declaration shapes found in the wild (spec plugin A-023): the
+     * wrapped `{"mcpServers": {…}}` and the flat `{"<serverName>": {…}}`, matching
+     * Claude Code's `parsed.mcpServers || parsed`. A plugin manifest that declares
+     * `mcpServers` inline is equivalent to a sibling `.mcp.json`; when both exist
+     * they are merged by server name, the file winning.
+     *
+     * @param manifestMcpServers Inline declarations from the plugin manifest
      */
-    static async loadMcpConfig(pluginPath) {
+    static async loadMcpConfig(pluginPath, manifestMcpServers) {
+        const servers = {
+            ...(manifestMcpServers ?? {}),
+        };
         const mcpPath = path.join(pluginPath, ".mcp.json");
         try {
             const content = await fs.readFile(mcpPath, "utf-8");
+            const parsed = JSON.parse(content);
             // Return raw config — let McpManager resolve templates and capture originalUrl
-            return JSON.parse(content);
+            Object.assign(servers, extractMcpServers(parsed));
         }
         catch {
-            return undefined;
+            // no .mcp.json — inline declarations (if any) stand alone
         }
+        if (Object.keys(servers).length === 0)
+            return undefined;
+        return { mcpServers: servers };
     }
     /**
      * Load hooks configuration from a plugin
@@ -197,11 +212,27 @@ export class PluginLoader {
         if (!manifest.description) {
             throw new Error("Plugin manifest missing 'description'");
         }
-        if (!manifest.version) {
-            throw new Error("Plugin manifest missing 'version'");
-        }
+        // `version` is optional: the Claude Code ecosystem omits it freely and the
+        // install path already defaults it (spec plugin A-022).
         if (!/^[a-z0-9-]+$/.test(manifest.name)) {
             throw new Error(`Invalid plugin name: ${manifest.name}. Only lowercase letters, numbers, and hyphens are allowed.`);
         }
     }
 }
+/**
+ * Normalizes an MCP declaration to a server map, accepting both the wrapped and
+ * the flat shape (spec plugin A-023). Anything that is not an object of server
+ * configs yields an empty map rather than throwing, so one malformed declaration
+ * cannot fail the whole plugin.
+ */
+function extractMcpServers(parsed) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+    }
+    const record = parsed;
+    const wrapped = record.mcpServers;
+    const servers = wrapped && typeof wrapped === "object" && !Array.isArray(wrapped)
+        ? wrapped
+        : record;
+    return servers;
+}

package/dist/services/remoteSettingsService.js

@@ -303,12 +303,26 @@ export function mergeRemoteSettings(localMerged, remote) {
         result.worktree = remote.worktree;
     if (remote.models !== undefined)
         result.models = remote.models;
+    // Plugin / marketplace maps merge per key (remote wins per key), like `env`
+    // above: the managed layer's keys override same-named local ones while every
+    // key the admin did not mention stays as the user configured it. A wholesale
+    // replace would silently drop all of a user's own plugins the moment an admin
+    // pushes a single managed one (spec enterprise server-managed-config
+    // 「托管配置下发插件市场与启用列表」场景 5, matching Claude Code's policy layer).
     if (remote.marketplaces !== undefined)
-        result.marketplaces = remote.marketplaces;
+        result.marketplaces = {
+            ...localMerged.marketplaces,
+            ...remote.marketplaces,
+        };
     if (remote.enabledPlugins !== undefined)
-        result.enabledPlugins = remote.enabledPlugins;
+        result.enabledPlugins = {
+            ...localMerged.enabledPlugins,
+            ...remote.enabledPlugins,
+        };
     if (remote.enableArtifact !== undefined)
         result.enableArtifact = remote.enableArtifact;
+    if (remote.enableExec !== undefined)
+        result.enableExec = remote.enableExec;
     return result;
 }
 /**

package/dist/services/session.d.ts

@@ -22,6 +22,13 @@ export interface SessionData {
         workdir: string;
         lastActiveAt: string;
         latestTotalTokens: number;
+        /**
+         * User-set title recovered from the whole-file scan (see
+         * `readMessagesAndCustomTitle`). Held in memory by the host so a later
+         * `reAppendSessionMetadata` can write it back at EOF even after later
+         * messages pushed it out of the tail window.
+         */
+        customTitle?: string;
     };
 }
 export interface SessionMetadata {
@@ -33,6 +40,11 @@ export interface SessionMetadata {
     lastActiveAt: Date;
     latestTotalTokens: number;
     firstMessage?: string;
+    /**
+     * User-set conversation title (from a `custom-title` entry in the session
+     * file). Takes precedence over `firstMessage` when rendering a label.
+     */
+    customTitle?: string;
     /** Git branch at session creation time (from the metadata header). */
     branch?: string;
 }
@@ -75,6 +87,21 @@ export declare function getSessionFilePath(sessionId: string, workdir: string, s
  * @param sessionType - Type of session ("main" or "subagent", defaults to "main")
  */
 export declare function createSession(sessionId: string, workdir: string, sessionType?: "main" | "subagent"): Promise<void>;
+/**
+ * Rewrite a session file down to its first `keepMessageCount` messages.
+ *
+ * The only caller is `/rewind`. Unlike `appendMessages` this removes history
+ * from the file, but it keeps every file-level reserved entry (metadata header,
+ * `custom-title`) byte for byte — dropping them would silently turn the session
+ * into the "legacy file without a header" shape, losing its creation time,
+ * git branch and user-set title.
+ *
+ * @param sessionId - UUID session identifier
+ * @param keepMessageCount - Number of leading messages to keep
+ * @param workdir - Working directory for the session
+ * @param sessionType - Type of session ("main" or "subagent", defaults to "main")
+ */
+export declare function truncateSession(sessionId: string, keepMessageCount: number, workdir: string, sessionType?: "main" | "subagent"): Promise<void>;
 /**
  * Append messages to session using JSONL format (new approach)
  *
@@ -84,6 +111,53 @@ export declare function createSession(sessionId: string, workdir: string, sessio
  * @param sessionType - Type of session ("main" or "subagent", defaults to "main")
  */
 export declare function appendMessages(sessionId: string, newMessages: Message[], workdir: string, sessionType?: "main" | "subagent"): Promise<void>;
+/**
+ * Set (or replace) a session's user-set title.
+ *
+ * The title is persisted as a `custom-title` entry appended to the session's
+ * own JSONL file — never as a rewrite of the metadata header, and never in a
+ * sidecar index — so every host that reads session files sees it without any
+ * extra sync channel.
+ *
+ * A session whose transcript has not been materialized yet (only meta messages
+ * so far) is created here: renaming is an explicit user action, so it is not
+ * subject to the "meta-only sessions never hit disk" rule.
+ *
+ * An empty/blank title is a no-op — it is not a signal to clear the title.
+ *
+ * @param sessionId - UUID session identifier
+ * @param workdir - Working directory the session belongs to
+ * @param title - New title
+ * @returns The trimmed title that was written, or undefined for a blank no-op
+ */
+export declare function setSessionCustomTitle(sessionId: string, workdir: string, title: string): Promise<string | undefined>;
+/**
+ * Re-append the session's reserved metadata entries at EOF.
+ *
+ * A listing reads only the tail window (64 KB) of each session file, so a
+ * `custom-title` entry that later messages pushed past that window becomes
+ * invisible — the session would flip back to showing its first message. This
+ * runs at the session's sparse flush points (spec `session-management.md`
+ * 验收场景 5): graceful exit, compaction, taking over a resumed session,
+ * switching away from one, and after `/rewind` rewrites the file. Claude Code
+ * solves the same problem the same way (`reAppendSessionMetadata`,
+ * `sessionStorage.ts:458/983/1533`, `compact.ts:711/1057`).
+ *
+ * The entry is refreshed from the tail first: another process (the CLI session
+ * picker, a second host) may have renamed the session while we held it, in
+ * which case its value — not our stale in-memory one — is the truth. When the
+ * tail holds nothing (already evicted, or never written by anyone else), the
+ * caller's in-memory value stands.
+ *
+ * A missing transcript file is a no-op: re-appending must never materialize a
+ * session that does not exist.
+ *
+ * @param sessionId - UUID session identifier
+ * @param workdir - Working directory the session belongs to
+ * @param customTitle - Title held in memory by the caller (may be undefined)
+ * @param sessionType - Type of session ("main" or "subagent", defaults to "main")
+ */
+export declare function reAppendSessionMetadata(sessionId: string, workdir: string, customTitle: string | undefined, sessionType?: "main" | "subagent"): Promise<void>;
 /**
  * Load session data from JSONL file (new approach)
  *

package/dist/services/session.js

@@ -22,6 +22,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { PathEncoder } from "../utils/pathEncoder.js";
 import { JsonlHandler } from "../services/jsonlHandler.js";
+import { isReservedEntry } from "../services/sessionEntries.js";
 import { extractLatestTotalTokens } from "../utils/tokenCalculation.js";
 import { logger } from "../utils/globalLogger.js";
 import { getMessageContent } from "../utils/messageOperations.js";
@@ -119,6 +120,35 @@ export async function createSession(sessionId, workdir, sessionType = "main") {
         gitBranch: await getGitBranch(workdir),
     });
 }
+/**
+ * Rewrite a session file down to its first `keepMessageCount` messages.
+ *
+ * The only caller is `/rewind`. Unlike `appendMessages` this removes history
+ * from the file, but it keeps every file-level reserved entry (metadata header,
+ * `custom-title`) byte for byte — dropping them would silently turn the session
+ * into the "legacy file without a header" shape, losing its creation time,
+ * git branch and user-set title.
+ *
+ * @param sessionId - UUID session identifier
+ * @param keepMessageCount - Number of leading messages to keep
+ * @param workdir - Working directory for the session
+ * @param sessionType - Type of session ("main" or "subagent", defaults to "main")
+ */
+export async function truncateSession(sessionId, keepMessageCount, workdir, sessionType = "main") {
+    // Do not save session files in test environment
+    if (process.env.NODE_ENV === "test") {
+        return;
+    }
+    const jsonlHandler = new JsonlHandler();
+    const filePath = await generateSessionFilePath(sessionId, workdir, sessionType);
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        throw new Error(`Session file not found: ${sessionId}. Cannot rewind a session that was never persisted.`);
+    }
+    await jsonlHandler.truncateSession(filePath, keepMessageCount);
+}
 /**
  * Append messages to session using JSONL format (new approach)
  *
@@ -146,10 +176,114 @@ export async function appendMessages(sessionId, newMessages, workdir, sessionTyp
     catch {
         throw new Error(`Session file not found: ${sessionId}. Use createSession() to create a new session first.`);
     }
+    // Append only. Keeping the title inside the listing's tail window is the
+    // job of `reAppendSessionMetadata`, which runs at the session's sparse flush
+    // points — not here: appending the entry on every save costs a tail read and
+    // an extra line per save, for a guarantee only needed once the session is
+    // about to be read from disk by someone else.
     await jsonlHandler.append(filePath, newMessages, {
         atomic: false,
     });
 }
+/**
+ * Set (or replace) a session's user-set title.
+ *
+ * The title is persisted as a `custom-title` entry appended to the session's
+ * own JSONL file — never as a rewrite of the metadata header, and never in a
+ * sidecar index — so every host that reads session files sees it without any
+ * extra sync channel.
+ *
+ * A session whose transcript has not been materialized yet (only meta messages
+ * so far) is created here: renaming is an explicit user action, so it is not
+ * subject to the "meta-only sessions never hit disk" rule.
+ *
+ * An empty/blank title is a no-op — it is not a signal to clear the title.
+ *
+ * @param sessionId - UUID session identifier
+ * @param workdir - Working directory the session belongs to
+ * @param title - New title
+ * @returns The trimmed title that was written, or undefined for a blank no-op
+ */
+export async function setSessionCustomTitle(sessionId, workdir, title) {
+    const trimmed = title.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const jsonlHandler = new JsonlHandler();
+    let filePath = await generateSessionFilePath(sessionId, workdir, "main");
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        // The session may live in another project directory (created from a
+        // different cwd, or a git worktree that no longer maps to this workdir).
+        const fallback = await findSessionFileAcrossProjects(sessionId, "main");
+        if (fallback) {
+            filePath = fallback;
+        }
+        else {
+            await createSession(sessionId, workdir, "main");
+            filePath = await generateSessionFilePath(sessionId, workdir, "main");
+        }
+    }
+    await jsonlHandler.appendCustomTitle(filePath, trimmed, sessionId);
+    return trimmed;
+}
+/**
+ * Re-append the session's reserved metadata entries at EOF.
+ *
+ * A listing reads only the tail window (64 KB) of each session file, so a
+ * `custom-title` entry that later messages pushed past that window becomes
+ * invisible — the session would flip back to showing its first message. This
+ * runs at the session's sparse flush points (spec `session-management.md`
+ * 验收场景 5): graceful exit, compaction, taking over a resumed session,
+ * switching away from one, and after `/rewind` rewrites the file. Claude Code
+ * solves the same problem the same way (`reAppendSessionMetadata`,
+ * `sessionStorage.ts:458/983/1533`, `compact.ts:711/1057`).
+ *
+ * The entry is refreshed from the tail first: another process (the CLI session
+ * picker, a second host) may have renamed the session while we held it, in
+ * which case its value — not our stale in-memory one — is the truth. When the
+ * tail holds nothing (already evicted, or never written by anyone else), the
+ * caller's in-memory value stands.
+ *
+ * A missing transcript file is a no-op: re-appending must never materialize a
+ * session that does not exist.
+ *
+ * @param sessionId - UUID session identifier
+ * @param workdir - Working directory the session belongs to
+ * @param customTitle - Title held in memory by the caller (may be undefined)
+ * @param sessionType - Type of session ("main" or "subagent", defaults to "main")
+ */
+export async function reAppendSessionMetadata(sessionId, workdir, customTitle, sessionType = "main") {
+    const jsonlHandler = new JsonlHandler();
+    let filePath = await generateSessionFilePath(sessionId, workdir, sessionType);
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        // The session may live in another project directory (created from a
+        // different cwd, or a git worktree). That sweep costs a directory walk per
+        // flush point, so it runs only when there is a title to write: with no
+        // in-memory title there is nothing this call could add that the entry
+        // already in the file does not say.
+        if (!customTitle) {
+            return;
+        }
+        const fallback = await findSessionFileAcrossProjects(sessionId, sessionType);
+        if (!fallback) {
+            return;
+        }
+        filePath = fallback;
+    }
+    // Absorb a fresher value written by another process since we last looked.
+    const tailTitle = await jsonlHandler.readCustomTitle(filePath);
+    const title = tailTitle ?? customTitle;
+    if (!title) {
+        return;
+    }
+    await jsonlHandler.appendCustomTitle(filePath, title, sessionId);
+}
 /**
  * Scan all project directories for a session file by ID. Used as a fallback
  * when the session is not found in the given working directory (e.g. resuming
@@ -214,7 +348,7 @@ export async function loadSessionFromJsonl(sessionId, workdir, sessionType = "ma
                 throw error;
             }
         }
-        const allMessages = await jsonlHandler.read(resolvedPath);
+        const { messages: allMessages, customTitle } = await jsonlHandler.readMessagesAndCustomTitle(resolvedPath);
         // Transcripts written by older CLI versions re-appended the preserved
         // rounds at each compaction point, so a message id can appear twice.
         // Keep the first occurrence — duplicates would render twice once the
@@ -244,6 +378,10 @@ export async function loadSessionFromJsonl(sessionId, workdir, sessionType = "ma
                 // messages appended (SessionStart hooks), which would otherwise report
                 // 0 and blank the context-usage indicator for that conversation.
                 latestTotalTokens: extractLatestTotalTokens(messages),
+                // Recovered from the whole-file scan, not the tail window: a title the
+                // conversation has long outgrown is only reachable this way. The host
+                // holds it in memory so `reAppendSessionMetadata` puts it back at EOF.
+                customTitle,
             },
         };
         return sessionData;
@@ -377,6 +515,8 @@ export async function listSessionsFromJsonl(workdir) {
                 catch {
                     // Ignore errors getting first message
                 }
+                // A user-set title, when present, wins over the first-message label.
+                sessionMeta.customTitle = await jsonlHandler.readCustomTitle(filePath);
                 sessions.push(sessionMeta);
             }
             catch {
@@ -553,6 +693,7 @@ export async function listAllSessions(options) {
                             // usage-less hook message, so the line alone would report 0.
                             latestTotalTokens: await jsonlHandler.getLatestTotalTokens(filePath),
                             firstMessage,
+                            customTitle: await jsonlHandler.readCustomTitle(filePath),
                             branch: header?.gitBranch,
                         });
                     }
@@ -733,8 +874,8 @@ export async function getFirstMessageContentFromFile(filePath) {
         for (const line of lines) {
             try {
                 const message = JSON.parse(line);
-                // Skip the metadata header line and meta messages
-                if (message.type === "metadata" || message.isMeta) {
+                // Skip reserved entries (metadata header, custom-title) and meta messages
+                if (isReservedEntry(message.type) || message.isMeta) {
                     continue;
                 }
                 const content = getMessageContent(message);

package/dist/services/sessionEntries.d.ts

@@ -0,0 +1,2 @@
+/** True when a parsed JSONL line is a reserved (non-message) entry. */
+export declare function isReservedEntry(type: string | undefined): boolean;

package/dist/services/sessionEntries.js

@@ -0,0 +1,20 @@
+/**
+ * Reserved (non-message) entry types found in a session JSONL file.
+ *
+ * A session file is an append-only log of messages plus a few reserved
+ * bookkeeping entries: the `metadata` header written once at creation, and a
+ * `custom-title` entry appended on every rename. Every reader must skip all of
+ * them — a reserved entry parsed as a message yields `lastActiveAt: Invalid
+ * Date`, corrupts the token scan, or surfaces in the conversation.
+ *
+ * Lives in its own dependency-free module because both the writer
+ * (`jsonlHandler.ts`) and the reader (`session.ts`) need it, and the session
+ * tests mock `jsonlHandler` wholesale.
+ *
+ * Add a new file-level entry type here when adding one.
+ */
+const RESERVED_ENTRY_TYPES = new Set(["metadata", "custom-title"]);
+/** True when a parsed JSONL line is a reserved (non-message) entry. */
+export function isReservedEntry(type) {
+    return type !== undefined && RESERVED_ENTRY_TYPES.has(type);
+}

package/dist/stdio/index.d.ts

@@ -3,7 +3,9 @@
  * app: a typed StdioAgent wrapper (mirrors the CLI Agent API over JSON-RPC)
  * plus the sessionId-demultiplexing NotificationRouter.
  *
- * Import via the `wave-agent-sdk/stdio` subpath.
+ * Re-exported by the `wave-agent-sdk/host` entry — import it from there. It has
+ * no subpath of its own: the RPC layer is only reachable through `/host`, so a
+ * host cannot pick it up by accident while reaching for a shared literal.
  */
 export * from "./rpcClient.js";
 export * from "./notificationRouter.js";

package/dist/stdio/index.js

@@ -3,7 +3,9 @@
  * app: a typed StdioAgent wrapper (mirrors the CLI Agent API over JSON-RPC)
  * plus the sessionId-demultiplexing NotificationRouter.
  *
- * Import via the `wave-agent-sdk/stdio` subpath.
+ * Re-exported by the `wave-agent-sdk/host` entry — import it from there. It has
+ * no subpath of its own: the RPC layer is only reachable through `/host`, so a
+ * host cannot pick it up by accident while reaching for a shared literal.
  */
 export * from "./rpcClient.js";
 export * from "./notificationRouter.js";

package/dist/stdio/notificationRouter.js

@@ -36,6 +36,7 @@ const ALL_NOTIFICATION_METHODS = [
     "compactBlockAdded",
     "compactionStateChange",
     "compactionContentUpdate",
+    "planFileUpdated",
     "backgroundTasksChange",
 ];
 export class NotificationRouter {

package/dist/stdio/stdioAgent.d.ts

@@ -30,9 +30,6 @@ export interface InitializeParams {
     defaultHeaders?: Record<string, string>;
     model?: string;
     fastModel?: string;
-    language?: string;
-    autoMemoryEnabled?: boolean;
-    autoMemoryFrequency?: number;
     permissionMode?: PermissionMode;
     tools?: string[];
     allowedTools?: string[];
@@ -48,6 +45,12 @@ export interface InitializeResult {
     permissionMode: PermissionMode;
     latestTotalTokens: number;
 }
+/**
+ * Session-level overrides only. 用户偏好（语言 / 上下文长度 / 自动记忆开关与频率）
+ * **不得**经本层下发——它们写用户级 `~/.wave/settings.json` 并由实时重载生效；
+ * 覆盖层优先级高于 settings.json，会把实时值永久遮蔽（docs/specs/core/agent-config.md
+ * 「分层职责」）。
+ */
 export interface UpdateConfigParams {
     apiKey?: string;
     baseURL?: string;
@@ -55,10 +58,6 @@ export interface UpdateConfigParams {
     defaultHeaders?: Record<string, string>;
     model?: string;
     fastModel?: string;
-    language?: string;
-    contextLength?: number;
-    autoMemoryEnabled?: boolean;
-    autoMemoryFrequency?: number;
 }
 export interface StdioAgentCallbacks {
     onUserMessageAdded?: (message: Message) => void;
@@ -78,6 +77,8 @@ export interface StdioAgentCallbacks {
     onCompactBlockAdded?: (content: string) => void;
     onCompactionStateChange?: (isCompacting: boolean) => void;
     onCompactionContentUpdate?: (content: string) => void;
+    /** Full plan-file content after the model writes it (spec: 计划文件更新后刷新计划面板). */
+    onPlanFileUpdated?: (content: string) => void;
     onLoadingChange?: (loading: boolean) => void;
     onContextUsage?: (percent: number) => void;
     onCommandRunningChange?: (running: boolean) => void;
@@ -134,6 +135,12 @@ export declare class StdioAgent {
     initialize(params: InitializeParams): Promise<InitializeResult>;
     destroy(): Promise<void>;
     restoreSession(sessionId: string): Promise<void>;
+    /**
+     * Set this session's custom title (spec session-management.md「会话自定义标题
+     * （重命名）」). The title is appended to the session's own JSONL file as a
+     * reserved `custom-title` entry, so every host reading that file sees it.
+     */
+    renameSession(title: string): Promise<void>;
     updateConfig(params: UpdateConfigParams): Promise<{
         sessionId: string;
     }>;

package/dist/stdio/stdioAgent.js

@@ -63,6 +63,20 @@ export class StdioAgent {
     async restoreSession(sessionId) {
         await this.client.request("restoreSession", { sessionId }, this.sessionId);
     }
+    /**
+     * Set this session's custom title (spec session-management.md「会话自定义标题
+     * （重命名）」). The title is appended to the session's own JSONL file as a
+     * reserved `custom-title` entry, so every host reading that file sees it.
+     */
+    async renameSession(title) {
+        await this.client.request("renameSession", {
+            sessionId: this.sessionId,
+            // The session file lives under the session root; a cwd drifted by `cd`
+            // inside a turn must not address it (see sessionCwd).
+            workdir: this.sessionCwd ?? this.workingDirectory,
+            title,
+        }, this.sessionId);
+    }
     async updateConfig(params) {
         const oldSessionId = this.sessionId;
         const result = (await this.client.request("updateConfig", params, this.sessionId));
@@ -261,6 +275,11 @@ export class StdioAgent {
                 this.callbacks.onCompactionContentUpdate?.(p.content);
                 break;
             }
+            case "planFileUpdated": {
+                const p = params;
+                this.callbacks.onPlanFileUpdated?.(p.content);
+                break;
+            }
             case "loadingChange": {
                 const p = params;
                 if (p.latestTotalTokens !== undefined) {