wave-agent-sdk 1.2.0 → 1.3.0

package/dist/services/initializationService.js

@@ -9,6 +9,25 @@ export class InitializationService {
         const startTime = performance.now();
         // Set global logger early so managers can use it during initialization
         setGlobalLogger(logger || null);
+        // Load the remote settings disk cache synchronously, before anything reads
+        // the configuration chain. Two consumers depend on it being this early:
+        // loadMergedConfiguration (below) merges the cached managed settings (env,
+        // model, disallowedTools), and plugin loading (also below) reads the managed
+        // enabledPlugins / marketplaces so an admin-pushed plugin is installed and
+        // enabled on this very startup (spec enterprise server-managed-config
+        // 「托管配置下发插件市场与启用列表」场景 1). Settings `env` is stored in the
+        // per-session env snapshot (NOT process.env), except WAVE_SERVER_URL which is
+        // mirrored to process.env so the network fetch (below) can read it via
+        // authService.getServerUrl(); no race.
+        try {
+            const phaseStart = performance.now();
+            await remoteSettingsService.initialize();
+            logger?.debug(`Initialization Phase [Remote Settings Cache] took ${(performance.now() - phaseStart).toFixed(2)}ms`);
+        }
+        catch (error) {
+            logger?.error("Failed to initialize remote settings:", error);
+            // Don't throw error to prevent app startup failure - continue without remote settings
+        }
         // Initialize managers first
         try {
             const phaseStart = performance.now();
@@ -44,21 +63,6 @@ export class InitializationService {
             logger?.error("Failed to initialize MCP servers:", error);
             // Don't throw error to prevent app startup failure
         }
-        // Load remote settings disk cache synchronously.
-        // Must happen BEFORE loadMergedConfiguration so cached managed settings
-        // (env, model, disallowedTools) are merged into the config. Settings `env`
-        // is stored in the per-session env snapshot (NOT process.env), except
-        // WAVE_SERVER_URL which is mirrored to process.env so the network fetch
-        // (below) can read it via authService.getServerUrl(); no race.
-        try {
-            const phaseStart = performance.now();
-            await remoteSettingsService.initialize();
-            logger?.debug(`Initialization Phase [Remote Settings Cache] took ${(performance.now() - phaseStart).toFixed(2)}ms`);
-        }
-        catch (error) {
-            logger?.error("Failed to initialize remote settings:", error);
-            // Don't throw error to prevent app startup failure - continue without remote settings
-        }
         // Initialize hooks configuration
         try {
             const phaseStart = performance.now();

package/dist/services/interactionService.d.ts

@@ -18,11 +18,19 @@ export interface InteractionContext {
     taskManager: TaskManager;
     options: AgentOptions;
     abortMessage: () => void;
+    /**
+     * Move every directory-derived piece of session state (session transcript
+     * location, project rules, memory caches) to another working directory.
+     * Used when restoring a session that lives in a different directory.
+     */
+    switchWorkdir: (workdir: string) => Promise<void>;
 }
 export declare class InteractionService {
     static sendMessage(context: InteractionContext, content: string, images?: Array<{
         path: string;
         mimeType: string;
     }>): Promise<void>;
-    static restoreSession(context: InteractionContext, sessionId: string): Promise<void>;
+    static restoreSession(context: InteractionContext, sessionId: string, restoreOptions?: {
+        workdir?: string;
+    }): Promise<void>;
 }

package/dist/services/interactionService.js

@@ -75,8 +75,14 @@ export class InteractionService {
             // Loading state will be automatically updated by the useEffect that watches messages
         }
     }
-    static async restoreSession(context, sessionId) {
-        const { messageManager, hookManager, logger, subagentManager, taskManager, options, abortMessage, } = context;
+    static async restoreSession(context, sessionId, restoreOptions) {
+        const { messageManager, hookManager, logger, subagentManager, taskManager, options, abortMessage, switchWorkdir, } = context;
+        // The target session may live in another project directory. Everything
+        // below that reads a path (loading the transcript, the SessionStart hook's
+        // transcript path, the next append) must use the target directory, never
+        // the current one — otherwise the switch writes a second copy of the same
+        // session into the current project directory.
+        const targetWorkdir = restoreOptions?.workdir ?? messageManager.getWorkdir();
         // 1. Validation
         if (!sessionId || sessionId === messageManager.getSessionId()) {
             return; // No-op if session ID is invalid or already current
@@ -89,6 +95,9 @@ export class InteractionService {
             logger?.warn("Failed to save current session before restore:", error);
             // Continue with restoration even if save fails
         }
+        // 2b. Flush point for the session being left behind: it is about to be
+        //     read from disk again by whoever lists sessions next.
+        await messageManager.reAppendSessionMetadata();
         // 3. Run SessionEnd hooks for the current session (cleanup before switching)
         const currentSessionId = messageManager.getSessionId();
         const currentTranscriptPath = messageManager.getTranscriptPath();
@@ -101,18 +110,29 @@ export class InteractionService {
             }
         }
         // 4. Load target session
-        const sessionData = await loadSessionFromJsonl(sessionId, messageManager.getWorkdir());
+        const sessionData = await loadSessionFromJsonl(sessionId, targetWorkdir);
         if (!sessionData) {
             throw new Error(`Session not found: ${sessionId}`);
         }
-        // 5. Clean current state
+        // 5. Move this session to the target directory. Only after the target
+        //    transcript has loaded successfully, so a failed restore leaves the
+        //    current session (and its directory) untouched.
+        if (targetWorkdir !== messageManager.getWorkdir()) {
+            await switchWorkdir(targetWorkdir);
+        }
+        // 6. Clean current state
         abortMessage(); // Abort any running operations
         subagentManager.cleanup(); // Clean up active subagents
-        // 6. Rebuild usage (in correct order)
+        // 7. Rebuild usage (in correct order)
         messageManager.rebuildUsageFromMessages(sessionData.messages);
-        // 7. Initialize session state last
+        // 8. Initialize session state last
         messageManager.initializeFromSession(sessionData);
-        // 8. Run SessionStart hooks for the restored session and inject additional
+        // 8b. Flush point for the session we just took over. `initializeFromSession`
+        //     has adopted the title recovered by the load-time whole-file scan, so
+        //     this is where a title that had slid out of the tail window is written
+        //     back at EOF (Claude Code's `adoptResumedSessionFile` does the same).
+        await messageManager.reAppendSessionMetadata();
+        // 9. Run SessionStart hooks for the restored session and inject additional
         //    context as a meta user message (matches Claude Code's resume behavior:
         //    SessionEnd then SessionStart, hook messages appended to the conversation)
         if (hookManager) {
@@ -131,7 +151,7 @@ export class InteractionService {
         }
         // Update task manager with the root session ID to ensure continuity across compactions
         taskManager.setTaskListId(sessionData.id);
-        // 9. Load tasks for the restored session
+        // 10. Load tasks for the restored session
         const tasks = await taskManager.listTasks();
         options.callbacks?.onTasksChange?.(tasks);
     }

package/dist/services/jsonlHandler.d.ts

@@ -24,6 +24,20 @@ export interface SessionMetadataHeader {
     /** Git branch at creation time (`git branch --show-current`), when the directory is a git repo. */
     gitBranch?: string;
 }
+/**
+ * User-set conversation title, appended as its own JSONL entry on rename.
+ * A dedicated entry type (rather than a field on the append-only metadata
+ * header) is what lets the title be changed after creation without rewriting
+ * the file: it is appended at rename time, and re-appended at EOF at the
+ * session's sparse flush points (`reAppendSessionMetadata` — exit, compaction,
+ * resume, rewind) rather than on every save.
+ */
+export interface CustomTitleEntry {
+    type: "custom-title";
+    customTitle: string;
+    /** Session the title belongs to (the file is per-session; kept for traceability). */
+    sessionId?: string;
+}
 /**
  * JSONL handler class for message persistence operations
  */
@@ -49,6 +63,26 @@ export declare class JsonlHandler {
      * Append a single message to JSONL file
      */
     appendMessage(filePath: string, message: Message): Promise<void>;
+    /**
+     * Append a user-set conversation title (`{"type":"custom-title",...}`).
+     *
+     * Appending — never rewriting — keeps the file's append-only contract intact
+     * and leaves the metadata header and every message untouched. The entry has
+     * no `timestamp`, so it can never be mistaken for a message by readers that
+     * filter on timestamps.
+     */
+    appendCustomTitle(filePath: string, customTitle: string, sessionId?: string): Promise<void>;
+    /**
+     * Read the session's user-set title from the tail window, if present.
+     *
+     * Scans the tail and keeps the newest entry, so a rename always wins over an
+     * earlier one. Only the tail is read: this is the cheap path used by session
+     * listing and by `reAppendSessionMetadata`'s external-writer refresh, and the
+     * write side re-appends the entry at EOF at its sparse flush points. An entry
+     * that later messages have already pushed out of the window is invisible
+     * here — that is what `readMessagesAndCustomTitle` recovers on resume.
+     */
+    readCustomTitle(filePath: string): Promise<string | undefined>;
     /**
      * Append multiple messages to JSONL file
      */
@@ -61,6 +95,24 @@ export declare class JsonlHandler {
      * Read all messages from JSONL file (simplified - no metadata handling)
      */
     read(filePath: string): Promise<Message[]>;
+    /**
+     * Read the whole file once, returning every message plus the newest
+     * `custom-title` entry.
+     *
+     * `readCustomTitle` only scans the tail window, so a title that later
+     * messages pushed out of it is invisible there. The whole file still holds
+     * it, and the resume path collects it here: that recovered value is what a
+     * later `reAppendSessionMetadata` writes back at EOF, which is what makes an
+     * evicted title self-heal instead of being lost for good.
+     *
+     * @param filePath - Path to the session JSONL file
+     * @returns The messages (reserved entries filtered out) and the newest
+     *          non-empty custom title, when the file carries one
+     */
+    readMessagesAndCustomTitle(filePath: string): Promise<{
+        messages: Message[];
+        customTitle?: string;
+    }>;
     /**
      * Get the last message from JSONL file using efficient file reading (simplified)
      */
@@ -89,6 +141,38 @@ export declare class JsonlHandler {
      * @returns The persisted metadata, or null when the file has no header
      */
     readMetadata(filePath: string): Promise<SessionMetadataHeader | null>;
+    /**
+     * Rewrite a session file keeping only its first `keepMessageCount` messages.
+     *
+     * This is the one operation that removes history from a session file
+     * (`/rewind`); every other write appends. It is a filter over the file's
+     * original lines rather than a re-serialization of parsed messages:
+     *
+     * - Reserved entries (`metadata` header, `custom-title`, and any type added
+     *   to `RESERVED_ENTRY_TYPES` later) are carried over byte for byte, wherever
+     *   they sit in the file. Rebuilding the file from `Message[]` used to lose
+     *   them — `read()` filters reserved entries out, so a rewrite could not see
+     *   the header or the title — which silently degraded the session to the
+     *   "legacy file without a header" shape: `createdAt` fell back to
+     *   `new Date()`, `gitBranch` vanished, and the title could never be read
+     *   back again.
+     * - Lines that are neither reserved nor a message (no `timestamp`) are also
+     *   carried over, so an entry type written by a newer version survives a
+     *   rewind performed by an older one.
+     * - Only message lines past `keepMessageCount` are dropped.
+     *
+     * The result is written to a temp file and renamed into place, so an
+     * interrupted rewrite leaves the original file untouched.
+     *
+     * The "is this a message line" test deliberately mirrors `read()`
+     * (`!isReservedEntry(type) && timestamp`) and the partial-trailing-line
+     * tolerance mirrors its interrupted-append handling, so the caller's message
+     * count and this file's line order stay in step.
+     *
+     * @param filePath - Session JSONL path (must already exist)
+     * @param keepMessageCount - Number of leading messages to keep
+     */
+    truncateSession(filePath: string, keepMessageCount: number): Promise<void>;
     /**
      * Validate messages before writing
      */

package/dist/services/jsonlHandler.js

@@ -2,10 +2,17 @@
  * JSONL file operations service
  * Handles reading and writing JSONL (JSON Lines) session files for improved performance
  */
-import { appendFile, readFile, writeFile, stat, mkdir } from "fs/promises";
+import { appendFile, readFile, writeFile, stat, mkdir, rename, unlink, } from "fs/promises";
+import { randomUUID } from "crypto";
 import { dirname } from "path";
-import { getLastLine, readFirstNLines, readTailLines, } from "../utils/fileUtils.js";
+import { forEachLine, getLastLine, readFirstNLines, readTailLines, } from "../utils/fileUtils.js";
 import { extractLatestTotalTokens } from "../utils/tokenCalculation.js";
+import { isReservedEntry } from "./sessionEntries.js";
+/**
+ * Flush threshold for `truncateSession`'s output buffer. Only bounds the
+ * rewrite's memory — the file it produces is identical regardless of value.
+ */
+const TRUNCATE_FLUSH_BYTES = 64 * 1024;
 /**
  * JSONL handler class for message persistence operations
  */
@@ -43,6 +50,49 @@ export class JsonlHandler {
     async appendMessage(filePath, message) {
         return this.appendMessages(filePath, [message]);
     }
+    /**
+     * Append a user-set conversation title (`{"type":"custom-title",...}`).
+     *
+     * Appending — never rewriting — keeps the file's append-only contract intact
+     * and leaves the metadata header and every message untouched. The entry has
+     * no `timestamp`, so it can never be mistaken for a message by readers that
+     * filter on timestamps.
+     */
+    async appendCustomTitle(filePath, customTitle, sessionId) {
+        const entry = {
+            type: "custom-title",
+            customTitle,
+            ...(sessionId ? { sessionId } : {}),
+        };
+        await this.ensureDirectory(dirname(filePath));
+        await appendFile(filePath, `${JSON.stringify(entry)}\n`, "utf8");
+    }
+    /**
+     * Read the session's user-set title from the tail window, if present.
+     *
+     * Scans the tail and keeps the newest entry, so a rename always wins over an
+     * earlier one. Only the tail is read: this is the cheap path used by session
+     * listing and by `reAppendSessionMetadata`'s external-writer refresh, and the
+     * write side re-appends the entry at EOF at its sparse flush points. An entry
+     * that later messages have already pushed out of the window is invisible
+     * here — that is what `readMessagesAndCustomTitle` recovers on resume.
+     */
+    async readCustomTitle(filePath) {
+        for (const line of (await readTailLines(filePath)).reverse()) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.type !== "custom-title")
+                    continue;
+                return typeof parsed.customTitle === "string" && parsed.customTitle
+                    ? parsed.customTitle
+                    : undefined;
+            }
+            catch {
+                // Partial line at the tail window's boundary — keep looking.
+            }
+        }
+        return undefined;
+    }
     /**
      * Append multiple messages to JSONL file
      */
@@ -87,6 +137,23 @@ export class JsonlHandler {
      * Read all messages from JSONL file (simplified - no metadata handling)
      */
     async read(filePath) {
+        return (await this.readMessagesAndCustomTitle(filePath)).messages;
+    }
+    /**
+     * Read the whole file once, returning every message plus the newest
+     * `custom-title` entry.
+     *
+     * `readCustomTitle` only scans the tail window, so a title that later
+     * messages pushed out of it is invisible there. The whole file still holds
+     * it, and the resume path collects it here: that recovered value is what a
+     * later `reAppendSessionMetadata` writes back at EOF, which is what makes an
+     * evicted title self-heal instead of being lost for good.
+     *
+     * @param filePath - Path to the session JSONL file
+     * @returns The messages (reserved entries filtered out) and the newest
+     *          non-empty custom title, when the file carries one
+     */
+    async readMessagesAndCustomTitle(filePath) {
         try {
             const content = await readFile(filePath, "utf8");
             // append() always terminates a written batch with "\n" (see append),
@@ -98,16 +165,26 @@ export class JsonlHandler {
                 .map((line) => line.trim())
                 .filter((line) => line.length > 0);
             if (lines.length === 0) {
-                return [];
+                return { messages: [] };
             }
             const allMessages = [];
-            // Parse all messages, skipping the metadata header line (if any)
+            let customTitle;
+            // Parse every line: real messages are kept, reserved entries (the
+            // metadata header, and custom titles) are read for their own fields.
             for (let i = 0; i < lines.length; i++) {
                 const line = lines[i];
                 try {
                     const message = JSON.parse(line);
-                    // Metadata header line: not a message, skip
-                    if (message.type === "metadata")
+                    if (message.type === "custom-title") {
+                        // Last one wins: a later rename supersedes an earlier one.
+                        if (typeof message.customTitle === "string" &&
+                            message.customTitle) {
+                            customTitle = message.customTitle;
+                        }
+                        continue;
+                    }
+                    // Any other reserved entry (metadata header): not a message
+                    if (isReservedEntry(message.type))
                         continue;
                     if (message.timestamp)
                         allMessages.push(message);
@@ -125,11 +202,11 @@ export class JsonlHandler {
                     throw new Error(`Invalid JSON at line ${i + 1}: ${error}`);
                 }
             }
-            return allMessages;
+            return { messages: allMessages, customTitle };
         }
         catch (error) {
             if (error.code === "ENOENT") {
-                return [];
+                return { messages: [] };
             }
             throw new Error(`Failed to read JSONL file "${filePath}": ${error}`);
         }
@@ -156,15 +233,28 @@ export class JsonlHandler {
             }
             try {
                 const parsed = JSON.parse(lastLine);
-                // A file whose only line is the metadata header has no messages yet
-                if (parsed.type === "metadata") {
-                    return null;
+                if (!isReservedEntry(parsed.type)) {
+                    return parsed;
                 }
-                return parsed;
             }
             catch (error) {
                 throw new Error(`Invalid JSON in last line of "${filePath}": ${error}`);
             }
+            // The file ends with a reserved entry — a `custom-title` appended by a
+            // rename, or the metadata header of a session with no messages yet. Both
+            // are non-messages, so walk the tail window back to the newest message.
+            for (const line of (await readTailLines(filePath)).reverse()) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (isReservedEntry(parsed.type))
+                        continue;
+                    return parsed;
+                }
+                catch {
+                    // Partial line at the tail window's boundary — keep looking.
+                }
+            }
+            return null;
         }
         catch (error) {
             throw new Error(`Failed to get last message from "${filePath}": ${error}`);
@@ -188,8 +278,8 @@ export class JsonlHandler {
         for (const line of await readTailLines(filePath)) {
             try {
                 const parsed = JSON.parse(line);
-                // Metadata header line: not a message, skip
-                if (parsed.type === "metadata")
+                // Reserved entry (metadata header, custom-title): not a message
+                if (isReservedEntry(parsed.type))
                     continue;
                 messages.push(parsed);
             }
@@ -229,6 +319,111 @@ export class JsonlHandler {
         }
         return null;
     }
+    /**
+     * Rewrite a session file keeping only its first `keepMessageCount` messages.
+     *
+     * This is the one operation that removes history from a session file
+     * (`/rewind`); every other write appends. It is a filter over the file's
+     * original lines rather than a re-serialization of parsed messages:
+     *
+     * - Reserved entries (`metadata` header, `custom-title`, and any type added
+     *   to `RESERVED_ENTRY_TYPES` later) are carried over byte for byte, wherever
+     *   they sit in the file. Rebuilding the file from `Message[]` used to lose
+     *   them — `read()` filters reserved entries out, so a rewrite could not see
+     *   the header or the title — which silently degraded the session to the
+     *   "legacy file without a header" shape: `createdAt` fell back to
+     *   `new Date()`, `gitBranch` vanished, and the title could never be read
+     *   back again.
+     * - Lines that are neither reserved nor a message (no `timestamp`) are also
+     *   carried over, so an entry type written by a newer version survives a
+     *   rewind performed by an older one.
+     * - Only message lines past `keepMessageCount` are dropped.
+     *
+     * The result is written to a temp file and renamed into place, so an
+     * interrupted rewrite leaves the original file untouched.
+     *
+     * The "is this a message line" test deliberately mirrors `read()`
+     * (`!isReservedEntry(type) && timestamp`) and the partial-trailing-line
+     * tolerance mirrors its interrupted-append handling, so the caller's message
+     * count and this file's line order stay in step.
+     *
+     * @param filePath - Session JSONL path (must already exist)
+     * @param keepMessageCount - Number of leading messages to keep
+     */
+    async truncateSession(filePath, keepMessageCount) {
+        const tempPath = `${filePath}.tmp.${process.pid}.${randomUUID()}`;
+        try {
+            // Materialize the temp file up front so an empty result still renames.
+            await writeFile(tempPath, "", "utf8");
+            let keptMessages = 0;
+            let pendingBrokenLine = false;
+            let buffered = [];
+            let bufferedLength = 0;
+            const flush = async () => {
+                if (buffered.length === 0) {
+                    return;
+                }
+                await appendFile(tempPath, buffered.join(""), "utf8");
+                buffered = [];
+                bufferedLength = 0;
+            };
+            const keepLine = async (line) => {
+                const chunk = `${line}\n`;
+                buffered.push(chunk);
+                bufferedLength += chunk.length;
+                if (bufferedLength >= TRUNCATE_FLUSH_BYTES) {
+                    await flush();
+                }
+            };
+            const handleLine = async (raw) => {
+                const line = raw.trim();
+                if (line.length === 0) {
+                    return;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch (error) {
+                    if (pendingBrokenLine) {
+                        throw new Error(`Invalid JSON in session file "${filePath}": ${error}`);
+                    }
+                    pendingBrokenLine = true;
+                    return;
+                }
+                // A parseable line after a broken one proves the broken line was not
+                // the file's last, so it is corruption rather than a partial write.
+                if (pendingBrokenLine) {
+                    throw new Error(`Invalid JSON in session file "${filePath}": truncated trailing line`);
+                }
+                if (isReservedEntry(parsed.type) || !parsed.timestamp) {
+                    await keepLine(line);
+                    return;
+                }
+                if (keptMessages < keepMessageCount) {
+                    keptMessages++;
+                    await keepLine(line);
+                }
+            };
+            const { endsWithNewline } = await forEachLine(filePath, handleLine);
+            // A broken line is only acceptable as the last line of a file that lacks
+            // a trailing newline — the residue of an interrupted append.
+            if (pendingBrokenLine && endsWithNewline) {
+                throw new Error(`Invalid JSON in session file "${filePath}"`);
+            }
+            await flush();
+            await rename(tempPath, filePath);
+        }
+        catch (error) {
+            try {
+                await unlink(tempPath);
+            }
+            catch {
+                // Cleanup is best effort — the original error is more important.
+            }
+            throw error;
+        }
+    }
     /**
      * Validate messages before writing
      */

package/dist/services/memory.d.ts

@@ -19,7 +19,9 @@ export declare class MemoryService {
      */
     ensureAutoMemoryDirectory(workdir: string): Promise<void>;
     /**
-     * Get the first 200 lines of MEMORY.md.
+     * Get the auto-memory entrypoint (`MEMORY.md`), bounded by both the line and
+     * the character cap. Truncation appends a warning naming the cap that fired,
+     * so the model can tell the index it is reading is incomplete.
      */
     getAutoMemoryContent(workdir: string): Promise<string>;
     ensureUserMemoryFile(): Promise<void>;

package/dist/services/memory.js

@@ -3,8 +3,11 @@ import * as path from "node:path";
 import { homedir } from "node:os";
 import { USER_MEMORY_FILE, DATA_DIRECTORY } from "../utils/constants.js";
 import { logger } from "../utils/globalLogger.js";
+import { atomicWriteFile } from "../utils/atomicWrite.js";
 import { getGitCommonDir } from "../utils/gitUtils.js";
 import { pathEncoder } from "../utils/pathEncoder.js";
+import { MEMORY_ENTRYPOINT_NAME } from "../constants/memory.js";
+import { truncateEntrypointContent } from "../utils/memoryEntrypoint.js";
 export class MemoryService {
     constructor(container) {
         this.container = container;
@@ -51,7 +54,7 @@ export class MemoryService {
             catch (error) {
                 if (error.code === "ENOENT") {
                     const initialContent = "# Project Memory\n\nThis file serves as an index for the project's auto-memory. Wave uses this to track knowledge across sessions.\n\n";
-                    await fs.writeFile(memoryFile, initialContent, "utf-8");
+                    await atomicWriteFile(memoryFile, initialContent);
                     logger.debug(`Created auto-memory file: ${memoryFile}`);
                 }
                 else {
@@ -65,18 +68,19 @@ export class MemoryService {
         }
     }
     /**
-     * Get the first 200 lines of MEMORY.md.
+     * Get the auto-memory entrypoint (`MEMORY.md`), bounded by both the line and
+     * the character cap. Truncation appends a warning naming the cap that fired,
+     * so the model can tell the index it is reading is incomplete.
      */
     async getAutoMemoryContent(workdir) {
         if (this._cachedAutoMemoryContent !== null) {
             return this._cachedAutoMemoryContent;
         }
         const memoryDir = this.getAutoMemoryDirectory(workdir);
-        const memoryFile = path.join(memoryDir, "MEMORY.md");
+        const memoryFile = path.join(memoryDir, MEMORY_ENTRYPOINT_NAME);
         try {
-            const content = await fs.readFile(memoryFile, "utf-8");
-            const lines = content.split("\n").slice(0, 200);
-            this._cachedAutoMemoryContent = lines.join("\n");
+            const raw = await fs.readFile(memoryFile, "utf-8");
+            this._cachedAutoMemoryContent = truncateEntrypointContent(raw).content;
             return this._cachedAutoMemoryContent;
         }
         catch (error) {
@@ -103,7 +107,7 @@ export class MemoryService {
                         userMemoryFile: USER_MEMORY_FILE,
                     });
                     const initialContent = "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
-                    await fs.writeFile(USER_MEMORY_FILE, initialContent, "utf-8");
+                    await atomicWriteFile(USER_MEMORY_FILE, initialContent);
                     logger.debug(`Created user memory file: ${USER_MEMORY_FILE}`);
                 }
                 else {
@@ -223,7 +227,7 @@ export class MemoryService {
      */
     async writeUserMemoryContent(content) {
         await this.ensureUserMemoryFile();
-        await fs.writeFile(USER_MEMORY_FILE, content, "utf-8");
+        await atomicWriteFile(USER_MEMORY_FILE, content);
         this._cachedUserMemory = null;
         this._cachedCombinedMemory = null;
         logger.debug("User memory content written", {
@@ -240,7 +244,7 @@ export class MemoryService {
     async writeProjectMemoryContent(workdir, content) {
         const memoryFilePath = path.join(workdir, "AGENTS.md");
         await fs.mkdir(workdir, { recursive: true });
-        await fs.writeFile(memoryFilePath, content, "utf-8");
+        await atomicWriteFile(memoryFilePath, content);
         this._cachedProjectMemory = null;
         this._cachedCombinedMemory = null;
         logger.debug("Project memory content written", {

package/dist/services/officialMarketplaceMirror.js

@@ -37,8 +37,9 @@ const STAGING_SUFFIX = ".staging";
  * - TEST（验证用）: `https://codechat.codewave-test.163yun.com/wave-plugins-official/`
  *
  * Override with env var `WAVE_OFFICIAL_MARKET_MIRROR_BASE_URL` (highest
- * precedence). 注意：prod 该 URL 的 ingress/内容尚未上线，镜像请求会 404 → 按既有
- * 设计回退 git 兜底（ALLOW_OFFICIAL_MARKET_GIT_FALLBACK），行为安全。
+ * precedence). 两套环境的镜像通道均已上线且有内容（2026-09-23 实测：prod 与 test 的
+ * `/latest` 均返回 sha、`{sha}.zip` 均可下载）。镜像请求若失败（网络/超时/404/内容异常），
+ * 仍按既有设计回退 git 兜底（ALLOW_OFFICIAL_MARKET_GIT_FALLBACK），语义不变。
  */
 const DEFAULT_OFFICIAL_MARKET_MIRROR_BASE_URL = "https://codechat.codewave.163.com/wave-plugins-official/";
 /** Env var override for the mirror base URL (highest precedence). */