wave-agent-sdk 1.1.4 → 1.2.0

package/dist/managers/slashCommandManager.js

@@ -14,34 +14,6 @@ export class SlashCommandManager {
     }
     initialize() {
         this.loadCustomCommands();
-        // Builtin /subtask: manual fork subagent (aligned with Claude Code's
-        // /subtask — inherits the parent's full context, runs in the background,
-        // result returns to the main conversation via a task notification).
-        this.registerCommand({
-            id: "subtask",
-            name: "subtask",
-            description: "Start a fork subagent with the current conversation context in the background",
-            handler: async (args, signal) => {
-                const taskDescription = args?.trim();
-                if (!taskDescription) {
-                    this.messageManager.addErrorBlock("Usage: /subtask <task description>");
-                    return;
-                }
-                try {
-                    // The fork snapshots its context synchronously on entry, so the
-                    // transcript echo below never duplicates the prompt inside the fork.
-                    await this.aiManager.runForkSubagent(taskDescription, { description: taskDescription }, signal);
-                    this.messageManager.addUserMessage({
-                        content: `/subtask ${taskDescription}`,
-                    });
-                }
-                catch (error) {
-                    this.aiManager.setIsLoading(false);
-                    logger?.error("Failed to execute /subtask:", error);
-                    this.messageManager.addErrorBlock(`Failed to execute /subtask: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            },
-        });
         // Listen for skill refreshes and update skill commands
         const skillManager = this.container.get("SkillManager");
         if (skillManager) {
@@ -103,6 +75,13 @@ export class SlashCommandManager {
             this.unregisterCommand(commandId);
         }
         this.skillCommandIds.clear();
+        const skillSourceFor = (skill) => {
+            if (skill.pluginName)
+                return "plugin";
+            if (skill.type === "personal")
+                return "user";
+            return skill.type; // "project" | "builtin"
+        };
         for (const skill of skills) {
             if (skill.userInvocable === false) {
                 continue;
@@ -113,6 +92,8 @@ export class SlashCommandManager {
                 id: commandId,
                 name: skill.name,
                 description: `Skill: ${skill.description}`,
+                // UI source tag: plugin skills carry pluginName; personal → 用户
+                skillSource: skillSourceFor(skill),
                 handler: async (args, signal) => {
                     try {
                         // 1. Prepare skill content immediately

package/dist/managers/subagentManager.d.ts

@@ -100,6 +100,13 @@ export declare class SubagentManager {
      * for conditional subagent registration (e.g. WAVE_VISION_MODEL).
      */
     private getMergedEnv;
+    /**
+     * Delete a user-level or project-level subagent by removing its markdown
+     * file. Builtin and plugin agents are read-only and cannot be deleted.
+     * @param name - The subagent name as shown in configurations
+     * @returns true if the subagent was deleted
+     */
+    deleteSubagent(name: string): Promise<boolean>;
     /**
      * Get cached configurations synchronously (must call loadConfigurations first)
      */

package/dist/managers/subagentManager.js

@@ -107,6 +107,31 @@ export class SubagentManager {
         return (this.configurationService?.getMergedEnv?.() ??
             process.env);
     }
+    /**
+     * Delete a user-level or project-level subagent by removing its markdown
+     * file. Builtin and plugin agents are read-only and cannot be deleted.
+     * @param name - The subagent name as shown in configurations
+     * @returns true if the subagent was deleted
+     */
+    async deleteSubagent(name) {
+        const configs = this.cachedConfigurations ?? [];
+        const config = configs.find((c) => c.name === name);
+        if (!config) {
+            return false;
+        }
+        // Builtin and plugin agents are read-only
+        if (config.scope !== "user" && config.scope !== "project") {
+            return false;
+        }
+        const { unlink } = await import("fs/promises");
+        await unlink(config.filePath);
+        // Drop the deleted agent from the cached configurations immediately.
+        // A later refreshConfigurations() re-scans the filesystem and reflects
+        // the deletion persistently.
+        this.cachedConfigurations = configs.filter((c) => c.name !== name);
+        logger?.debug(`Deleted subagent '${name}' at ${config.filePath}`);
+        return true;
+    }
     /**
      * Get cached configurations synchronously (must call loadConfigurations first)
      */
@@ -339,8 +364,13 @@ export class SubagentManager {
                         const result = await this.internalExecute(instance, prompt, abortSignal);
                         const task = backgroundTaskManager?.getTask(taskId);
                         if (task) {
-                            task.status = "completed";
-                            task.stdout = result;
+                            // internalExecute already recorded the terminal state; only fill
+                            // in a "completed" status when the task was not concurrently
+                            // killed (mirrors the catch branch below).
+                            if (task.status !== "killed") {
+                                task.status = "completed";
+                                task.stdout = result;
+                            }
                             task.endTime = Date.now();
                             task.runtime = task.endTime - startTime;
                         }
@@ -348,9 +378,13 @@ export class SubagentManager {
                     catch (error) {
                         const task = backgroundTaskManager?.getTask(taskId);
                         if (task) {
-                            task.status = "failed";
-                            task.stderr =
-                                error instanceof Error ? error.message : String(error);
+                            // Preserve a "killed" terminal state (internalExecute already
+                            // notified it) instead of flipping the in-map task to failed.
+                            if (task.status !== "killed") {
+                                task.status = "failed";
+                                task.stderr =
+                                    error instanceof Error ? error.message : String(error);
+                            }
                             task.endTime = Date.now();
                             task.runtime = task.endTime - startTime;
                         }
@@ -480,8 +514,13 @@ export class SubagentManager {
                 const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
                 if (task) {
                     const wasAlreadyKilled = task.status === "killed";
-                    task.status = "completed";
-                    task.stdout = response || "Agent completed with no text response";
+                    // Preserve a "killed" terminal state (stopTask already notified it)
+                    // instead of overwriting it with "completed" — mirrors shell exit
+                    // semantics in BackgroundTaskManager.onExit.
+                    if (!wasAlreadyKilled) {
+                        task.status = "completed";
+                        task.stdout = response || "Agent completed with no text response";
+                    }
                     task.endTime = Date.now();
                     if (task.startTime) {
                         task.runtime = task.endTime - task.startTime;
@@ -496,6 +535,11 @@ export class SubagentManager {
                             messageQueue.enqueueNotification(`<task-notification>\n<task-id>${instance.backgroundTaskId}</task-id>\n<task-type>agent</task-type>\n<status>completed</status>\n<summary>${summary}</summary>\n</task-notification>`);
                         }
                     }
+                    // Push a terminal snapshot: SubagentManager mutates the task object in
+                    // place, so without an explicit notify the UI/hosts keep the last
+                    // snapshot — the task created with status "running" — and the IDE
+                    // background-task gate (new chat / history restore) stays locked.
+                    backgroundTaskManager.notifyTasksChange();
                 }
             }
             return response || "Agent completed with no text response";
@@ -512,12 +556,20 @@ export class SubagentManager {
                 const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
                 if (task) {
                     const wasAlreadyKilled = task.status === "killed";
-                    task.status = "failed";
-                    task.stderr = error instanceof Error ? error.message : String(error);
+                    // Preserve a user/agent-initiated "killed" terminal state instead of
+                    // overwriting it with "failed" (mirrors shell exit semantics) — the
+                    // abort that stopped the task surfaces here as a thrown error.
+                    if (!wasAlreadyKilled) {
+                        task.status = "failed";
+                        task.stderr =
+                            error instanceof Error ? error.message : String(error);
+                    }
                     task.endTime = Date.now();
                     if (task.startTime) {
                         task.runtime = task.endTime - task.startTime;
                     }
+                    // Push a terminal snapshot (see the completion branch above).
+                    backgroundTaskManager.notifyTasksChange();
                     // Skip notification if task was already stopped (e.g. by main agent shutdown)
                     if (!wasAlreadyKilled) {
                         const messageQueue = this.container.has("MessageQueue")

package/dist/managers/workflowManager.js

@@ -207,6 +207,10 @@ export class WorkflowManager {
                     task.status = "completed";
                     task.endTime = Date.now();
                 }
+                // Push the terminal snapshot: without it the last snapshot holds the
+                // "running" registration and UI consumers (background-task gate) never
+                // see the workflow finish.
+                this.backgroundTaskManager.notifyTasksChange();
                 // Enqueue completion notification
                 const journalPath = journal.filePath;
                 this.messageQueue.enqueueNotification(taskNotificationToXml({
@@ -244,6 +248,8 @@ export class WorkflowManager {
                     task.stderr = run.error || "";
                     task.endTime = Date.now();
                 }
+                // Push the terminal snapshot (see the completion branch above).
+                this.backgroundTaskManager.notifyTasksChange();
                 this.messageQueue.enqueueNotification(taskNotificationToXml({
                     type: "task_notification",
                     taskId: runId,

package/dist/prompts/index.d.ts

@@ -1,7 +1,6 @@
 import { ToolPlugin } from "../tools/types.js";
 import type { WorktreeSession } from "../utils/worktreeSession.js";
 export declare const BASE_SYSTEM_PROMPT = "You are a coding agent developed by NetEase that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.";
-export declare const MODEL_IDENTITY_PROMPT = "# Model identity\n\nIf asked about your model, model version, underlying architecture, or product name, identify yourself simply as a coding agent developed by NetEase. Do not reveal the specific model ID, model family, model provider, or product name. Do not mention or hint at any of these details.";
 export declare const DOING_TASKS_PROMPT = "# Doing tasks\n- The user will primarily request you to perform software engineering tasks. These may include solving bugs, adding new functionality, refactoring code, explaining code, and more. When given an unclear or generic instruction, consider it in the context of these software engineering tasks and the current working directory. For example, if the user asks you to change \"methodName\" to snake case, do not reply with just \"method_name\", instead find the method in the code and modify the code.\n- You are highly capable and often allow users to complete ambitious tasks that would otherwise be too complex or take too long. You should defer to user judgement about whether a task is too large to attempt.\n- If you notice the user's request is based on a misconception, or spot a bug adjacent to what they asked about, say so. You're a collaborator, not just an executor\u2014users benefit from your judgment, not just your compliance.\n- In general, do not propose changes to code you haven't read. If a user asks about or wants you to modify a file, read it first. Understand existing code before suggesting modifications.\n- Do not create files unless they're absolutely necessary for achieving your goal. Generally prefer editing an existing file to creating a new one, as this prevents file bloat and builds on existing work more effectively.\n- If an approach fails, diagnose why before switching tactics\u2014read the error, check your assumptions, try a focused fix. Don't retry the identical action blindly, but don't abandon a viable approach after a single failure either. Escalate to the user with AskUserQuestion only when you're genuinely stuck after investigation, not as a first response to friction.\n- Be careful not to introduce security vulnerabilities such as command injection, XSS, SQL injection, and other OWASP top 10 vulnerabilities. If you notice that you wrote insecure code, immediately fix it. Prioritize writing safe, secure, and correct code.\n- Avoid over-engineering. Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused.\n  - Don't add features, refactor code, or make \"improvements\" beyond what was asked. A bug fix doesn't need surrounding code cleaned up. A simple feature doesn't need extra configurability. Don't add docstrings, comments, or type annotations to code you didn't change. Only add comments where the logic isn't self-evident.\n  - Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs). Don't use feature flags or backwards-compatibility shims when you can just change the code.\n  - Don't create helpers, utilities, or abstractions for one-time operations. Don't design for hypothetical future requirements. The right amount of complexity is what the task actually requires\u2014no speculative abstractions, but no half-finished implementations either. Three similar lines of code is better than a premature abstraction.\n- Avoid backwards-compatibility hacks like renaming unused _vars, re-exporting types, adding // removed comments for removed code, etc. If you are certain that something is unused, you can delete it completely.\n- Report outcomes faithfully: if tests fail, say so with the relevant output; if you did not run a verification step, say that rather than implying it succeeded. Never claim \"all tests pass\" when output shows failures, never suppress or simplify failing checks (tests, lints, type errors) to manufacture a green result, and never characterize incomplete or broken work as done. Equally, when a check did pass or a task is complete, state it plainly \u2014 do not hedge confirmed results with unnecessary disclaimers, downgrade finished work to \"partial,\" or re-verify things you already checked. The goal is an accurate report, not a defensive one.\n- Before reporting a task complete, verify it actually works: run the test, execute the script, check the output. Minimum complexity means no gold-plating, not skipping the finish line. If you can't verify (no test exists, can't run the code), say so explicitly rather than claiming success.";
 export declare const EXECUTING_ACTIONS_PROMPT = "# Executing actions with care\n\nCarefully consider the reversibility and blast radius of actions. Generally you can freely take local, reversible actions like editing files or running tests. But for actions that are hard to reverse, affect shared systems beyond your local environment, or could otherwise be risky or destructive, check with the user before proceeding. The cost of pausing to confirm is low, while the cost of an unwanted action (lost work, unintended messages sent, deleted branches) can be very high. For actions like these, consider the context, the action, and user instructions, and by default transparently communicate the action and ask for confirmation before proceeding.\n\nExamples of the kind of risky actions that warrant user confirmation:\n- Destructive operations: deleting files/branches, dropping database tables, killing processes, rm -rf, overwriting uncommitted changes\n- Hard-to-reverse operations: force-pushing (can also overwrite upstream), git reset --hard, amending published commits, removing or downgrading packages/dependencies, modifying CI/CD pipelines\n- Actions visible to others or that affect shared state: pushing code, creating/closing/commenting on PRs or issues, sending messages (Slack, email, GitHub), posting to external services\n\nWhen you encounter an obstacle, do not use destructive actions as a shortcut to simply make it go away. For instance, try to identify root causes and fix underlying issues rather than bypassing safety checks (e.g. --no-verify). If you discover unexpected state like unfamiliar files, branches, or configuration, investigate before deleting or overwriting, as it may represent the user's in-progress work. For example, typically resolve merge conflicts rather than discarding changes. In short: only take risky actions carefully, and when in doubt, ask before acting. Follow both the spirit and letter of these instructions - measure twice, cut once.";
 export declare const TOOL_POLICY = "# Using your tools\n\n- Do NOT use the Bash to run commands when a relevant dedicated tool is provided. Using dedicated tools allows the user to better understand and review your work. This is CRITICAL to assisting the user:\n  - To read files use Read instead of cat, head, tail, or sed\n  - To edit files use Edit instead of sed or awk\n  - To create files use Write instead of cat or echo redirection\n  - To search for files use Glob instead of find or ls\n  - To search the content of files, use Grep instead of grep or rg\n  - Reserve using the Bash exclusively for system commands and terminal operations that require shell execution. If you are unsure and there is a relevant dedicated tool, default to using the dedicated tool and only fallback on using the Bash tool for these if it is absolutely necessary.\n- You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency.\n- However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead. Never use placeholders or guess missing parameters in tool calls.\n- If the user specifies that they want you to run tools \"in parallel\", you MUST send a single message with multiple tool use content blocks.";

package/dist/prompts/index.js

@@ -4,9 +4,6 @@ import { buildAutoMemoryPrompt } from "./autoMemory.js";
 import { EXPLORE_SUBAGENT_TYPE, PLAN_SUBAGENT_TYPE, } from "../constants/subagents.js";
 import { ASK_USER_QUESTION_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, AGENT_TOOL_NAME, BASH_TOOL_NAME, READ_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, } from "../constants/tools.js";
 export const BASE_SYSTEM_PROMPT = `You are a coding agent developed by NetEase that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`;
-export const MODEL_IDENTITY_PROMPT = `# Model identity
-
-If asked about your model, model version, underlying architecture, or product name, identify yourself simply as a coding agent developed by NetEase. Do not reveal the specific model ID, model family, model provider, or product name. Do not mention or hint at any of these details.`;
 export const DOING_TASKS_PROMPT = `# Doing tasks
 - The user will primarily request you to perform software engineering tasks. These may include solving bugs, adding new functionality, refactoring code, explaining code, and more. When given an unclear or generic instruction, consider it in the context of these software engineering tasks and the current working directory. For example, if the user asks you to change "methodName" to snake case, do not reply with just "method_name", instead find the method in the code and modify the code.
 - You are highly capable and often allow users to complete ambitious tasks that would otherwise be too complex or take too long. You should defer to user judgement about whether a task is too large to attempt.
@@ -332,7 +329,6 @@ export function buildSystemPrompt(basePrompt, tools, options = {}) {
     }
     staticText += `\n\n${OUTPUT_EFFICIENCY_PROMPT}`;
     staticText += `\n\n${TONE_AND_STYLE_PROMPT}`;
-    staticText += `\n\n${MODEL_IDENTITY_PROMPT}`;
     const blocks = [{ text: staticText, cacheable: true }];
     // --- Dynamic block (not cacheable) ---
     let dynamicText = "";

package/dist/services/MarketplaceService.js

@@ -3,6 +3,7 @@ import * as path from "path";
 import * as crypto from "crypto";
 import { getPluginsDir } from "../utils/configPaths.js";
 import { GitService } from "./GitService.js";
+import { ALLOW_OFFICIAL_MARKET_GIT_FALLBACK, fetchOfficialMarketplaceFromMirror, } from "./officialMarketplaceMirror.js";
 import { ConfigurationService } from "./configurationService.js";
 import { logger, logError, logWarn } from "../utils/globalLogger.js";
 /**
@@ -510,25 +511,46 @@ export class MarketplaceService {
             const errors = [];
             for (const marketplace of toUpdate) {
                 try {
-                    if (marketplace.source.source === "github" ||
-                        marketplace.source.source === "git") {
-                        if (!isGitAvailable) {
-                            logWarn(`Skipping update for Git/GitHub marketplace "${marketplace.name}" because Git is not installed.`);
-                            continue;
-                        }
+                    // Builtin official marketplace: prefer the zip-snapshot mirror
+                    // (content-addressed zip over a plain HTTP base, no git/GitHub
+                    // needed). Only the builtin is special-cased by name — its
+                    // `source` stays "github" in settings/cache, so there is zero
+                    // data migration. On mirror failure (e.g. prod URL not yet live)
+                    // fall back to the git path unless the kill switch forbids it.
+                    const isOfficialBuiltin = marketplace.name === MarketplaceService.BUILTIN_MARKETPLACE.name;
+                    let mirrorUpdated = false;
+                    if (isOfficialBuiltin) {
                         const targetPath = this.getMarketplacePath(marketplace.source);
-                        if (existsSync(targetPath)) {
-                            await this.gitService.pull(targetPath);
+                        const mirrorSha = await fetchOfficialMarketplaceFromMirror(targetPath, this.marketplacesDir);
+                        if (mirrorSha !== null) {
+                            mirrorUpdated = true;
                         }
-                        else {
-                            let url;
-                            if (marketplace.source.source === "github") {
-                                url = marketplace.source.repo;
+                        else if (!ALLOW_OFFICIAL_MARKET_GIT_FALLBACK) {
+                            logWarn(`Skipping update for official marketplace "${marketplace.name}": mirror fetch failed and git fallback is disabled.`);
+                            continue;
+                        }
+                    }
+                    if (marketplace.source.source === "github" ||
+                        marketplace.source.source === "git") {
+                        if (!mirrorUpdated) {
+                            if (!isGitAvailable) {
+                                logWarn(`Skipping update for Git/GitHub marketplace "${marketplace.name}" because Git is not installed.`);
+                                continue;
+                            }
+                            const targetPath = this.getMarketplacePath(marketplace.source);
+                            if (existsSync(targetPath)) {
+                                await this.gitService.pull(targetPath);
                             }
                             else {
-                                url = marketplace.source.url;
+                                let url;
+                                if (marketplace.source.source === "github") {
+                                    url = marketplace.source.repo;
+                                }
+                                else {
+                                    url = marketplace.source.url;
+                                }
+                                await this.gitService.clone(url, targetPath, marketplace.source.ref);
                             }
-                            await this.gitService.clone(url, targetPath, marketplace.source.ref);
                         }
                     }
                     const manifest = await this.loadMarketplaceManifest(this.getMarketplacePath(marketplace.source));

package/dist/services/configurationService.d.ts

@@ -4,6 +4,7 @@
  * Centralized service for loading, validating, and managing Wave configuration files.
  * Replaces distributed configuration logic previously embedded in hook.ts.
  */
+import type { HookEvent, HookEventConfig } from "../types/hooks.js";
 import type { ConfigurationLoadResult, ValidationResult, ConfigurationPaths, WaveConfiguration, Scope, MarketplaceConfig } from "../types/configuration.js";
 import { type EnvironmentValidationResult, type MergedEnvironmentContext, type EnvironmentMergeOptions } from "../types/environment.js";
 import { GatewayConfig, ModelConfig, PermissionMode, AgentOptions } from "../types/index.js";
@@ -107,7 +108,7 @@ export declare class ConfigurationService {
     resolveLanguage(constructorLanguage?: string): string | undefined;
     /**
      * Resolves auto-memory enabled state with fallbacks
-     * Resolution priority: settings.json > WAVE_DISABLE_AUTO_MEMORY > default (true)
+     * Resolution priority: session options (host settings-page value) > settings.json > WAVE_DISABLE_AUTO_MEMORY > default (true)
      * @returns Resolved auto-memory enabled state
      */
     resolveAutoMemoryEnabled(): boolean;
@@ -119,7 +120,7 @@ export declare class ConfigurationService {
     resolveWorktreeBaseRef(): "fresh" | "head";
     /**
      * Resolves auto-memory extraction frequency with fallbacks
-     * Resolution priority: settings.json > WAVE_AUTO_MEMORY_FREQUENCY > default (1)
+     * Resolution priority: session options (host settings-page value) > settings.json > WAVE_AUTO_MEMORY_FREQUENCY > default (1)
      * @returns Resolved auto-memory extraction frequency (turns)
      */
     resolveAutoMemoryFrequency(): number;
@@ -160,6 +161,28 @@ export declare class ConfigurationService {
      * Update the enabled state of a plugin in the specified scope
      */
     updateEnabledPlugin(workdir: string, scope: Scope, pluginId: string, enabled: boolean): Promise<void>;
+    /**
+     * Resolve the settings.json path for a hook scope.
+     * user → ~/.wave/settings.json; project → <workdir>/.wave/settings.json
+     */
+    private resolveHookConfigPath;
+    /**
+     * Absolute path of the settings.json that holds hooks for `scope`
+     * (user → ~/.wave/settings.json, project → <workdir>/.wave/settings.json).
+     * Hosts surface it to the GUI so editors / file panels can open the file —
+     * they cannot expand a `~` prefix, so the path must already be absolute.
+     */
+    getHookConfigPath(workdir: string, scope: "user" | "project"): string;
+    /**
+     * Get hook configurations at a specific scope (user or project settings.json)
+     */
+    getHooksByScope(workdir: string, scope: Scope): Promise<Partial<Record<HookEvent, HookEventConfig[]>>>;
+    /**
+     * Delete a hook at a specific scope, identified by hookName of the form
+     * `Event:Matcher`. Removes the matching entry from the scope's settings.json
+     * hooks block.
+     */
+    deleteHook(workdir: string, scope: Scope, hookName: string): Promise<void>;
     /**
      * Get merged marketplaces from all scopes
      */
@@ -216,3 +239,12 @@ export declare function loadUserConfigEnv(): Record<string, string>;
  * Checks .local.json files first, then falls back to .json files
  */
 export declare function loadMergedWaveConfig(workdir: string): WaveConfiguration | null;
+/**
+ * Parse a hookName of the form `Event:Matcher` (e.g. `PreToolUse:Write`)
+ * into its event and matcher parts. Hooks without a matcher use the event
+ * name alone (e.g. `SessionStart`).
+ */
+export declare function parseHookName(hookName: string): {
+    event: HookEvent;
+    matcher: string;
+};

package/dist/services/configurationService.js

@@ -119,8 +119,8 @@ export function validateConfigurationObject(config) {
                     result.errors.push("All permission deny rules must be strings");
                 }
             }
-            // Validate permissionMode if present
-            if (config.permissions.permissionMode !== undefined) {
+            // Validate defaultMode if present
+            if (config.permissions.defaultMode !== undefined) {
                 const validModes = [
                     "default",
                     "bypassPermissions",
@@ -128,9 +128,9 @@ export function validateConfigurationObject(config) {
                     "plan",
                     "dontAsk",
                 ];
-                if (!validModes.includes(config.permissions.permissionMode)) {
+                if (!validModes.includes(config.permissions.defaultMode)) {
                     result.isValid = false;
-                    result.errors.push(`Invalid permissionMode: "${config.permissions.permissionMode}". Must be one of: ${validModes.join(", ")}`);
+                    result.errors.push(`Invalid defaultMode: "${config.permissions.defaultMode}". Must be one of: ${validModes.join(", ")}`);
                 }
             }
         }
@@ -590,21 +590,26 @@ export class ConfigurationService {
     }
     /**
      * Resolves auto-memory enabled state with fallbacks
-     * Resolution priority: settings.json > WAVE_DISABLE_AUTO_MEMORY > default (true)
+     * Resolution priority: session options (host settings-page value) > settings.json > WAVE_DISABLE_AUTO_MEMORY > default (true)
      * @returns Resolved auto-memory enabled state
      */
     resolveAutoMemoryEnabled() {
-        // 1. settings.json (merged)
+        // 1. Per-session options override (hosts pass the settings-page toggle over
+        //    stdio initialize/updateConfig; Agent.create → setOptions stores it)
+        if (this.options.autoMemoryEnabled !== undefined) {
+            return this.options.autoMemoryEnabled;
+        }
+        // 2. settings.json (merged)
         if (this.currentConfiguration?.autoMemoryEnabled !== undefined) {
             return this.currentConfiguration.autoMemoryEnabled;
         }
-        // 2. WAVE_DISABLE_AUTO_MEMORY environment variable (settings snapshot > OS env)
+        // 3. WAVE_DISABLE_AUTO_MEMORY environment variable (settings snapshot > OS env)
         const disableAutoMemory = this.envSnapshot.WAVE_DISABLE_AUTO_MEMORY ??
             process.env.WAVE_DISABLE_AUTO_MEMORY;
         if (disableAutoMemory === "1" || disableAutoMemory === "true") {
             return false;
         }
-        // 3. Default (true)
+        // 4. Default (true)
         return true;
     }
     /**
@@ -621,15 +626,23 @@ export class ConfigurationService {
     }
     /**
      * Resolves auto-memory extraction frequency with fallbacks
-     * Resolution priority: settings.json > WAVE_AUTO_MEMORY_FREQUENCY > default (1)
+     * Resolution priority: session options (host settings-page value) > settings.json > WAVE_AUTO_MEMORY_FREQUENCY > default (1)
      * @returns Resolved auto-memory extraction frequency (turns)
      */
     resolveAutoMemoryFrequency() {
-        // 1. settings.json (merged)
+        // 1. Per-session options override (hosts pass the settings-page value over
+        //    stdio initialize/updateConfig; Agent.create → setOptions stores it).
+        //    Only positive values are honored so a malformed 0/negative never
+        //    degenerates into per-turn extraction.
+        if (this.options.autoMemoryFrequency !== undefined &&
+            this.options.autoMemoryFrequency > 0) {
+            return this.options.autoMemoryFrequency;
+        }
+        // 2. settings.json (merged)
         if (this.currentConfiguration?.autoMemoryFrequency !== undefined) {
             return this.currentConfiguration.autoMemoryFrequency;
         }
-        // 2. WAVE_AUTO_MEMORY_FREQUENCY environment variable (settings snapshot > OS env)
+        // 3. WAVE_AUTO_MEMORY_FREQUENCY environment variable (settings snapshot > OS env)
         const envFrequency = this.envSnapshot.WAVE_AUTO_MEMORY_FREQUENCY ??
             process.env.WAVE_AUTO_MEMORY_FREQUENCY;
         if (envFrequency) {
@@ -638,7 +651,7 @@ export class ConfigurationService {
                 return parsed;
             }
         }
-        // 3. Default (1)
+        // 4. Default (1)
         return 1;
     }
     /**
@@ -840,6 +853,86 @@ export class ConfigurationService {
         config.enabledPlugins[pluginId] = enabled;
         await atomicWriteFile(configPath, JSON.stringify(config, null, 2));
     }
+    /**
+     * Resolve the settings.json path for a hook scope.
+     * user → ~/.wave/settings.json; project → <workdir>/.wave/settings.json
+     */
+    resolveHookConfigPath(workdir, scope) {
+        const configPath = scope === "user"
+            ? getUserConfigPaths()[0]
+            : getProjectConfigPaths(workdir)[1];
+        return { configPath, configDir: path.dirname(configPath) };
+    }
+    /**
+     * Absolute path of the settings.json that holds hooks for `scope`
+     * (user → ~/.wave/settings.json, project → <workdir>/.wave/settings.json).
+     * Hosts surface it to the GUI so editors / file panels can open the file —
+     * they cannot expand a `~` prefix, so the path must already be absolute.
+     */
+    getHookConfigPath(workdir, scope) {
+        return this.resolveHookConfigPath(workdir, scope).configPath;
+    }
+    /**
+     * Get hook configurations at a specific scope (user or project settings.json)
+     */
+    async getHooksByScope(workdir, scope) {
+        if (scope !== "user" && !existsSync(workdir)) {
+            return {};
+        }
+        const { configPath } = this.resolveHookConfigPath(workdir, scope);
+        if (!existsSync(configPath)) {
+            return {};
+        }
+        try {
+            const content = await fs.readFile(configPath, "utf-8");
+            const config = JSON.parse(content);
+            return config.hooks || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Delete a hook at a specific scope, identified by hookName of the form
+     * `Event:Matcher`. Removes the matching entry from the scope's settings.json
+     * hooks block.
+     */
+    async deleteHook(workdir, scope, hookName) {
+        if (scope !== "user" && !existsSync(workdir)) {
+            throw new Error(`Working directory does not exist: ${workdir}`);
+        }
+        const { configPath, configDir } = this.resolveHookConfigPath(workdir, scope);
+        if (!existsSync(configDir)) {
+            await fs.mkdir(configDir, { recursive: true });
+        }
+        let config = {};
+        if (existsSync(configPath)) {
+            try {
+                const content = await fs.readFile(configPath, "utf-8");
+                config = JSON.parse(content);
+            }
+            catch {
+                // Start with empty config if file is corrupted
+            }
+        }
+        const hooks = config.hooks || {};
+        const { event, matcher } = parseHookName(hookName);
+        if (!isValidHookEvent(event)) {
+            throw new Error(`Invalid hook event: ${event}`);
+        }
+        const eventConfigs = hooks[event];
+        if (eventConfigs) {
+            const remaining = eventConfigs.filter((cfg) => (cfg.matcher || "") !== (matcher || ""));
+            if (remaining.length > 0) {
+                hooks[event] = remaining;
+            }
+            else {
+                delete hooks[event];
+            }
+            config.hooks = hooks;
+            await atomicWriteFile(configPath, JSON.stringify(config, null, 2));
+        }
+    }
     /**
      * Get merged marketplaces from all scopes
      */
@@ -1195,10 +1288,9 @@ export function loadMergedWaveConfig(workdir) {
                     ]),
                 ];
             }
-            // Merge permissionMode (last one wins)
-            if (config.permissions.permissionMode !== undefined) {
-                mergedConfig.permissions.permissionMode =
-                    config.permissions.permissionMode;
+            // Merge defaultMode (last one wins)
+            if (config.permissions.defaultMode !== undefined) {
+                mergedConfig.permissions.defaultMode = config.permissions.defaultMode;
             }
             // Merge additionalDirectories
             if (config.permissions.additionalDirectories) {
@@ -1294,3 +1386,18 @@ export function loadMergedWaveConfig(workdir) {
         enableArtifact: mergedConfig.enableArtifact,
     };
 }
+/**
+ * Parse a hookName of the form `Event:Matcher` (e.g. `PreToolUse:Write`)
+ * into its event and matcher parts. Hooks without a matcher use the event
+ * name alone (e.g. `SessionStart`).
+ */
+export function parseHookName(hookName) {
+    const separator = hookName.indexOf(":");
+    if (separator === -1) {
+        return { event: hookName, matcher: "" };
+    }
+    return {
+        event: hookName.slice(0, separator),
+        matcher: hookName.slice(separator + 1),
+    };
+}

package/dist/services/initializationService.js

@@ -84,8 +84,8 @@ export class InitializationService {
                     if (configResult.configuration.permissions.deny) {
                         permissionManager.updateDeniedRules(configResult.configuration.permissions.deny);
                     }
-                    if (configResult.configuration.permissions.permissionMode) {
-                        permissionManager.updateConfiguredPermissionMode(configResult.configuration.permissions.permissionMode);
+                    if (configResult.configuration.permissions.defaultMode) {
+                        permissionManager.updateConfiguredPermissionMode(configResult.configuration.permissions.defaultMode);
                     }
                     if (configResult.configuration.permissions.additionalDirectories) {
                         permissionManager.updateAdditionalDirectories(configResult.configuration.permissions.additionalDirectories);

package/dist/services/jsonlHandler.d.ts

@@ -65,6 +65,20 @@ export declare class JsonlHandler {
      * Get the last message from JSONL file using efficient file reading (simplified)
      */
     getLastMessage(filePath: string): Promise<Message | null>;
+    /**
+     * Latest context-usage total for a session file.
+     *
+     * Sessions accumulate usage-less messages at the end — SessionStart hook
+     * meta messages are appended (and persisted) on every resume — so the last
+     * line alone cannot answer "how much context did this conversation use".
+     * Scan backwards over the file's tail window and take the newest message
+     * that carries usage.
+     *
+     * @param filePath - Path to the session JSONL file
+     * @returns total_tokens of the newest usage-bearing message, or 0 when the
+     *          tail holds none (empty/unreadable file, no completed request yet)
+     */
+    getLatestTotalTokens(filePath: string): Promise<number>;
     /**
      * Read the creation-time metadata from the session file's header line.
      *