wave-agent-sdk 0.19.7 → 0.19.9

package/builtin/plugins/sdd/.wave-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "sdd",
+  "description": "Spec-first workflow: specify skill, SessionStart guidance, and spec-count validation.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Wave Team"
+  }
+}

package/builtin/plugins/sdd/hooks/hooks.json

@@ -0,0 +1,14 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${WAVE_PLUGIN_ROOT}/scripts/session-start.js\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/builtin/plugins/sdd/scripts/session-start.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// SessionStart hook for the sdd built-in plugin.
+// Emits the spec-first workflow guidance as additionalContext (JSON form),
+// resolving the absolute path to the plugin's spec-count validator so the
+// agent can run it from its bash tool (which does not carry WAVE_PLUGIN_ROOT).
+import path from "node:path";
+
+const root =
+  process.env.WAVE_PLUGIN_ROOT ||
+  path.dirname(new URL("..", import.meta.url).pathname);
+const specCount = `node ${JSON.stringify(path.join(root, "scripts", "spec-count.js"))}`;
+
+const guidance = [
+  "Spec-First Workflow（规格优先工作流）：",
+  "- 需求增加或变更时，优先更新 spec：先更新对应规格说明（新增用户故事、验收场景），待用户确认 spec 后再实现代码。spec 是功能设计的权威来源，不是 changelog。",
+  "- 边界模糊时也先写 spec 草稿请用户确认，不要直接改代码。",
+  "- 使用 /sdd:specify 技能创建或更新规格文件。",
+  `- 新增或修改 spec 后运行校验：${specCount}（自动检测 docs/specs/，否则 specs/，否则退出）。`,
+].join("\n");
+
+// JSON form → parsed as hookSpecificOutput.additionalContext by the hook manager.
+console.log(
+  JSON.stringify({ hookSpecificOutput: { additionalContext: guidance } }),
+);

package/builtin/plugins/sdd/scripts/spec-count.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// Generic, self-contained spec validator. Counts user stories and acceptance
+// scenarios under the project's specs directory and warns on missing sections.
+// Detects the specs dir: prefers docs/specs/, else specs/, else exits gracefully.
+// No dependency on any project's VitePress/docs-site modules.
+import fs from "node:fs";
+import path from "node:path";
+
+function detectSpecsDir() {
+  for (const dir of ["docs/specs", "specs"]) {
+    const resolved = path.resolve(process.cwd(), dir);
+    if (fs.existsSync(resolved)) return resolved;
+  }
+  return null;
+}
+
+function walk(dir, out = []) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) walk(fullPath, out);
+    else if (entry.isFile() && entry.name.endsWith(".md")) out.push(fullPath);
+  }
+  return out;
+}
+
+function countUserStories(content) {
+  const m = content.match(/^### 用户故事[：:]/gm);
+  return m ? m.length : 0;
+}
+
+function countAcceptanceScenarios(content) {
+  const m = content.match(/^\d+\.\s+\*\*假设\*\*/gm);
+  return m ? m.length : 0;
+}
+
+const specsDir = detectSpecsDir();
+if (!specsDir) {
+  console.log("未找到规格目录（docs/specs/ 或 specs/），跳过校验。");
+  process.exit(0);
+}
+
+const files = walk(specsDir).sort();
+const totals = { specs: 0, us: 0, ac: 0 };
+const warnings = [];
+
+// index.md is conventionally a directory listing page, not a spec — skip it.
+const specFiles = files.filter(
+  (fp) => path.basename(fp).toLowerCase() !== "index.md",
+);
+
+for (const fp of specFiles) {
+  const content = fs.readFileSync(fp, "utf-8");
+  const usCount = countUserStories(content);
+  const acCount = countAcceptanceScenarios(content);
+  const rel = path.relative(process.cwd(), fp);
+  totals.specs++;
+  totals.us += usCount;
+  totals.ac += acCount;
+  if (!content.match(/^## 用户场景与测试/m))
+    warnings.push(`${rel}: 缺少 "## 用户场景与测试" 章节`);
+  if (usCount === 0)
+    warnings.push(`${rel}: 未找到用户故事（期望 \`### 用户故事：\`）`);
+  if (acCount === 0)
+    warnings.push(
+      `${rel}: 未找到验收场景（期望 \`N. **假设** … **当** … **则** …\`）`,
+    );
+  console.log(`${rel}  用户故事: ${usCount}  验收场景: ${acCount}`);
+}
+
+console.log("---");
+console.log(
+  `规格: ${totals.specs}  用户故事: ${totals.us}  验收场景: ${totals.ac}`,
+);
+if (warnings.length) {
+  for (const w of warnings) console.warn(`⚠ ${w}`);
+  console.warn(`⚠ ${warnings.length} 条模板警告——见上方。`);
+}

package/builtin/plugins/sdd/skills/specify/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: specify
+description: 根据自然语言描述创建或更新功能规格说明，生成包含用户故事与验收场景的规格文件。
+---
+
+## 用户输入
+
+```text
+$ARGUMENTS
+```
+
+你**必须**在继续之前考虑用户输入（如果不为空）。
+
+## 流程
+
+用户在 `/sdd:specify` 后输入的文本就是功能描述。不要让用户重复，除非他们提供了空命令。
+
+根据功能描述，执行以下步骤：
+
+1. **确定规格文件路径**：
+   - **确定规格根目录**：优先复用项目中已有的规格目录——若 `docs/specs/` 存在则用之，否则若 `specs/` 存在则用之，否则默认 `specs/`（并在完成报告中说明所选目录，便于用户纠正）。
+   - **选择分组**：若规格目录下已有分组子目录，沿用其既有分组约定；否则默认扁平结构（直接放在规格根目录下）。
+   - 根据功能描述生成 2-4 个词的 slug（小写、连字符、保留缩写词），与组内已有文件名不冲突
+   - 规格文件路径：`<规格根目录>/<分组>/<slug>.md`（无分组时为 `<规格根目录>/<slug>.md`）
+
+2. **加载模板** `${WAVE_SKILL_DIR}/templates/spec-template.md`，了解必需章节。
+
+3. **编写规格说明**：
+   - 解析用户描述，提取关键概念：角色、操作、数据、约束
+   - 对于不明确的部分，根据上下文和行业标准做出合理推断
+   - 仅在关键决策处标记 `[待澄清：具体问题]`（最多 3 处）
+   - 填写 frontmatter（`name` 为功能中文名、`description` 为一句话简述、`order` 为控制组内排序的数字）
+   - 填写「用户场景与测试」章节，包含按优先级排序的用户故事（P1、P2、P3...），每个故事以「作为…，我希望…，以便…」描述，附 `**为什么是这个优先级**` 与 `**独立测试**`（不适用的可省略）
+   - 为每个用户故事编写可测试的验收场景（**假设** … **当** … **则** …）
+   - 写入规格文件，替换所有占位符
+
+4. **如果存在 `[待澄清]` 标记**（最多 3 处）：
+   - 将每个标记作为问题展示，附带建议答案
+   - 等待用户回复后更新规格文件
+
+5. 报告完成，输出规格文件路径。
+
+## 指南
+
+- 关注用户**需要什麼**和**为什么**，而非如何实现
+- 不包含实现细节（不涉及技术栈、API、代码结构）
+- 每个验收场景必须可测试、无歧义
+- 删除不适用的可选章节（不要留 "N/A"）

package/builtin/plugins/sdd/skills/specify/templates/spec-template.md

@@ -0,0 +1,47 @@
+---
+name: "[功能名称]"
+description: "[一句话简短描述]"
+order: [数字，控制组内排序]
+---
+
+# 功能规格说明：[功能名称]
+
+**创建日期**：[日期]
+
+## 用户场景与测试 *（必填）*
+
+### 用户故事：[简要标题]（优先级：P1）
+
+作为[角色]，我希望[操作]，以便[价值/目的]。
+
+**为什么是这个优先级**：[解释其价值以及为何具有此优先级]
+
+**独立测试**：[描述如何独立测试——例如，"可以通过 [具体操作] 进行完整测试，并交付 [具体价值]"]
+
+**验收场景**：
+
+1. **假设** [初始状态]，**当** [操作]，**则** [预期结果]
+2. **假设** [初始状态]，**当** [操作]，**则** [预期结果]
+
+---
+
+### 用户故事：[简要标题]（优先级：P2）
+
+作为[角色]，我希望[操作]，以便[价值/目的]。
+
+**为什么是这个优先级**：[解释其价值以及为何具有此优先级]
+
+**独立测试**：[描述如何独立测试]
+
+**验收场景**：
+
+1. **假设** [初始状态]，**当** [操作]，**则** [预期结果]
+
+---
+
+[根据需要添加更多用户故事，每个都分配优先级]
+
+### 边界情况
+
+- **[问题？]** [答案/处理方式]
+- **[问题？]** [答案/处理方式]

package/dist/agent.d.ts

@@ -24,6 +24,7 @@ export declare class Agent {
     private reversionManager;
     private messageQueue;
     private dispatchPromise;
+    private isAborting;
     private memoryRuleManager;
     private liveConfigManager;
     private taskManager;
@@ -390,4 +391,11 @@ export declare class Agent {
      * Check if there are any running background tasks or active subagents
      */
     get hasRunningBackgroundWork(): boolean;
+    /**
+     * Check if there are pending items (messages, bang commands, or background
+     * task notifications) in the message queue. Background task completion
+     * notifications are enqueued before the main agent's dispatch consumes them,
+     * so callers waiting for the agent to fully settle must also wait on this.
+     */
+    get hasPendingMessages(): boolean;
 }

package/dist/agent.js

@@ -52,6 +52,7 @@ export class Agent {
     constructor(options) {
         this.bangManager = null;
         this.dispatchPromise = null; // Track current dispatch for teardown
+        this.isAborting = false; // Guard: prevents tryDispatch from firing during abortMessage
         this.sessionStartTime = Date.now();
         const { logger, workdir, systemPrompt, stream = true } = options;
         // Set working directory early as we need it for loading configuration
@@ -278,6 +279,8 @@ export class Agent {
      * onLoadingChange(false), and onCommandRunningChange(false).
      */
     tryDispatch() {
+        if (this.isAborting)
+            return; // Suppress dispatch during abort to prevent queued notifications from being dispatched as a side-effect
         if (this.messageQueue.state !== "idle")
             return;
         if (!this.messageQueue.hasPending())
@@ -632,17 +635,25 @@ export class Agent {
     }
     /** Unified interrupt method, interrupts both AI messages and command execution */
     abortMessage() {
-        if (this.aiManager.isLoading || this.isCommandRunning) {
-            // Clear user-facing queue items first to prevent processQueuedMessage
-            // from dequeuing when abortAIMessage triggers onLoadingChange(false).
-            // Notifications are preserved so background task results aren't lost.
-            this.messageQueue.clear();
-            this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
+        // Guard: prevent tryDispatch (triggered by abortAIMessage → setIsLoading(false))
+        // from dispatching preserved notifications as a new AI turn during the abort.
+        this.isAborting = true;
+        try {
+            if (this.aiManager.isLoading || this.isCommandRunning) {
+                // Clear user-facing queue items first to prevent processQueuedMessage
+                // from dequeuing when abortAIMessage triggers onLoadingChange(false).
+                // Notifications are preserved so background task results aren't lost.
+                this.messageQueue.clear();
+                this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
+            }
+            this.messageQueue.transitionTo("idle"); // Reset state on abort
+            this.abortAIMessage(); // This will abort tools including Agent tool (subagents)
+            this.abortBashCommand();
+            this.abortSlashCommand();
+        }
+        finally {
+            this.isAborting = false;
         }
-        this.messageQueue.transitionTo("idle"); // Reset state on abort
-        this.abortAIMessage(); // This will abort tools including Agent tool (subagents)
-        this.abortBashCommand();
-        this.abortSlashCommand();
     }
     /** Interrupt bash command execution */
     abortBashCommand() {
@@ -978,4 +989,13 @@ export class Agent {
         const activeSubagents = this.subagentManager.getActiveInstances().length > 0;
         return runningTasks || activeSubagents;
     }
+    /**
+     * Check if there are pending items (messages, bang commands, or background
+     * task notifications) in the message queue. Background task completion
+     * notifications are enqueued before the main agent's dispatch consumes them,
+     * so callers waiting for the agent to fully settle must also wait on this.
+     */
+    get hasPendingMessages() {
+        return this.messageQueue.hasPending();
+    }
 }

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export * from "./utils/tokenCalculation.js";
 export * from "./utils/gitUtils.js";
 export * from "./utils/nameGenerator.js";
 export * from "./utils/worktreeSession.js";
+export { loadMergedWaveConfig } from "./services/configurationService.js";
 export * from "./types/index.js";
 export * from "./tools/buildTool.js";
 export type { ToolPlugin, ToolResult, ToolContext } from "./tools/types.js";

package/dist/index.js

@@ -26,6 +26,7 @@ export * from "./utils/tokenCalculation.js";
 export * from "./utils/gitUtils.js";
 export * from "./utils/nameGenerator.js";
 export * from "./utils/worktreeSession.js";
+export { loadMergedWaveConfig } from "./services/configurationService.js";
 export * from "./types/index.js";
 // Export tool building utilities
 export * from "./tools/buildTool.js";

package/dist/managers/aiManager.d.ts

@@ -58,6 +58,7 @@ export declare class AIManager {
     getMaxInputTokens(): number;
     getLanguage(): string | undefined;
     getAutoMemoryEnabled(): boolean;
+    getWorktreeBaseRef(): "fresh" | "head";
     getWorkdir(): string;
     getOriginalWorkdir(): string;
     /**
@@ -102,6 +103,23 @@ export declare class AIManager {
         customInstructions?: string;
         abortSignal?: AbortSignal;
     }): Promise<void>;
+    /**
+     * Build the system prompt used by the main agent loop. Extracted so the
+     * compaction fork can mirror it exactly — the forked request prefix must
+     * match the main conversation's for the prompt cache to be reused.
+     */
+    private buildMainSystemPrompt;
+    private resolveFilteredTools;
+    /**
+     * Fork-path compaction: run a bounded agent loop over a copy of the
+     * conversation using the same system prompt, tools, model, and generation
+     * params as the main loop, so the forked request prefix matches exactly
+     * and the prompt cache is reused. Tool calls are denied locally (the model
+     * is told to summarize, not act) and their rejections are fed back for
+     * another turn. Returns undefined content when the model never produces
+     * text; the caller treats that as a compaction failure.
+     */
+    private runCompactFork;
     /**
      * Build post-compact context restoration content.
      * Restores file reads, working directory, plan mode, skills, and background tasks.

package/dist/managers/aiManager.js

@@ -6,8 +6,8 @@ import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js"
 import { estimateTokens } from "../utils/tokenEstimate.js";
 import { getTaskReminderTurnCounts, maybeInjectTaskReminder, TASK_REMINDER_CONFIG, } from "../utils/taskReminder.js";
 import { existsSync } from "node:fs";
-import { buildSystemPrompt } from "../prompts/index.js";
-import { buildPlanModeReminder, buildPlanModeReEntryReminder, buildExitedPlanModeReminder, } from "../prompts/planModeReminders.js";
+import { buildSystemPrompt, formatCompactSummary, getCompactPrompt, } from "../prompts/index.js";
+import { buildPlanModeReminder, buildPlanModeReEntryReminder, buildExitedPlanModeReminder, wrapInSystemReminder, } from "../prompts/planModeReminders.js";
 import { recoverTruncatedJson } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
 import { startInteractionSpan, endInteractionSpan, startLLMRequestSpan, endLLMRequestSpan, resetTracingState, } from "../telemetry/sessionTracing.js";
@@ -128,6 +128,9 @@ export class AIManager {
     getAutoMemoryEnabled() {
         return this.configurationService.resolveAutoMemoryEnabled();
     }
+    getWorktreeBaseRef() {
+        return this.configurationService.resolveWorktreeBaseRef();
+    }
     getWorkdir() {
         return this.container.get("Workdir") ?? process.cwd();
     }
@@ -345,30 +348,35 @@ export class AIManager {
         await this.messageManager.saveSession();
         this.setIsCompacting(true);
         try {
-            const recentChatMessages = convertMessagesForAPI(messagesToCompact);
-            // 4. Call compactMessages with optional custom instructions
-            const compactResult = await aiService.compactMessages({
-                gatewayConfig: this.getGatewayConfig(),
-                modelConfig: this.getModelConfig(),
-                messages: recentChatMessages,
-                abortSignal: options.abortSignal,
-                model: this.getModelConfig().fastModel,
-                customInstructions: mergedInstructions,
+            const modelConfig = this.getModelConfig();
+            const recentChatMessages = convertMessagesForAPI(messagesToCompact, {
+                supportsVision: supportsVision(modelConfig.capabilities),
             });
+            const compactPrompt = getCompactPrompt(mergedInstructions);
+            // 4. Fork path: fork the conversation with the same system prompt,
+            // tools, model, and generation params as the main loop so the forked
+            // request prefix matches exactly and the prompt cache is reused.
+            const forkResult = await this.runCompactFork(recentChatMessages, compactPrompt, options.abortSignal);
+            const summaryContent = forkResult.content;
+            const compactTokens = forkResult.usage;
+            if (!summaryContent) {
+                throw new Error("Compaction failed: the model produced no summary output");
+            }
+            const compactModel = modelConfig.model;
             // 5. Handle usage tracking
             let compactUsage;
-            if (compactResult.usage) {
+            if (compactTokens) {
                 compactUsage = {
-                    prompt_tokens: compactResult.usage.prompt_tokens,
-                    completion_tokens: compactResult.usage.completion_tokens,
-                    total_tokens: compactResult.usage.total_tokens,
-                    model: this.getModelConfig().fastModel,
+                    ...compactTokens,
+                    model: compactModel,
                     operation_type: "compact",
                 };
             }
-            // 6. Build post-compact context restoration
-            const enhancedSummary = await this.buildPostCompactContext(compactResult.content);
-            // 7. Execute message reconstruction
+            // 6. Strip the <analysis> scratchpad and extract the <summary> body
+            const formattedSummary = formatCompactSummary(summaryContent);
+            // 7. Build post-compact context restoration
+            const enhancedSummary = await this.buildPostCompactContext(formattedSummary);
+            // 8. Execute message reconstruction
             await this.messageManager.compactMessagesAndUpdateSession(enhancedSummary, compactUsage);
             // Re-add plan mode reminder as persistent meta message after compaction
             const postCompactMode = this.permissionManager?.getCurrentEffectiveMode(this.getModelConfig().permissionMode);
@@ -382,20 +390,20 @@ export class AIManager {
                     });
                 }
             }
-            // 8. Track usage
+            // 9. Track usage
             if (compactUsage && this.callbacks?.onUsageAdded) {
                 this.callbacks.onUsageAdded(compactUsage);
             }
             this.consecutiveCompactionFailures = 0;
             // Reset incremental tracing state after compaction
             resetTracingState();
-            // 9. Log OTEL event
+            // 10. Log OTEL event
             logOTelEvent("compaction", {
                 beforeTokens: String(messagesToCompact.length),
                 afterTokens: "1",
-                model: this.getModelConfig().fastModel,
+                model: compactModel,
             }).catch(() => { });
-            // 10. Run SessionStart hooks (existing behavior)
+            // 11. Run SessionStart hooks (existing behavior)
             if (this.hookManager) {
                 try {
                     const newSessionId = this.messageManager.getSessionId();
@@ -417,10 +425,10 @@ export class AIManager {
                     logger?.warn(`SessionStart hooks on compact failed: ${error.message}`);
                 }
             }
-            // 11. Run PostCompact hooks
+            // 12. Run PostCompact hooks
             if (this.hookManager) {
                 try {
-                    await this.hookManager.executePostCompactHooks(this.messageManager.getSessionId(), this.messageManager.getTranscriptPath(), compactResult.content);
+                    await this.hookManager.executePostCompactHooks(this.messageManager.getSessionId(), this.messageManager.getTranscriptPath(), formattedSummary);
                 }
                 catch (error) {
                     logger?.warn(`PostCompact hooks failed: ${error.message}`);
@@ -437,6 +445,115 @@ export class AIManager {
             this.setIsCompacting(false);
         }
     }
+    /**
+     * Build the system prompt used by the main agent loop. Extracted so the
+     * compaction fork can mirror it exactly — the forked request prefix must
+     * match the main conversation's for the prompt cache to be reused.
+     */
+    async buildMainSystemPrompt(filteredToolPlugins) {
+        let autoMemoryOptions;
+        if (this.getAutoMemoryEnabled()) {
+            const directory = this.memoryService.getAutoMemoryDirectory(this.getWorkdir());
+            const content = await this.memoryService.getAutoMemoryContent(this.getWorkdir());
+            autoMemoryOptions = { directory, content };
+        }
+        return buildSystemPrompt(this.systemPrompt, filteredToolPlugins, {
+            workdir: this.getWorkdir(),
+            originalWorkdir: this.getOriginalWorkdir(),
+            language: this.getLanguage(),
+            isSubagent: !!this.subagentType,
+            worktreeSession: this.getWorktreeSession(),
+            autoMemory: autoMemoryOptions,
+        });
+    }
+    resolveFilteredTools() {
+        const toolsConfig = this.getFilteredToolsConfig();
+        const toolNames = new Set(toolsConfig.map((t) => t.function.name));
+        const filteredToolPlugins = this.toolManager
+            .getTools()
+            .filter((t) => toolNames.has(t.name));
+        return { toolsConfig, toolNames, filteredToolPlugins };
+    }
+    /**
+     * Fork-path compaction: run a bounded agent loop over a copy of the
+     * conversation using the same system prompt, tools, model, and generation
+     * params as the main loop, so the forked request prefix matches exactly
+     * and the prompt cache is reused. Tool calls are denied locally (the model
+     * is told to summarize, not act) and their rejections are fed back for
+     * another turn. Returns undefined content when the model never produces
+     * text; the caller treats that as a compaction failure.
+     */
+    async runCompactFork(historyMessages, compactPrompt, abortSignal) {
+        const MAX_FORK_TURNS = 3;
+        const modelConfig = this.getModelConfig();
+        const gatewayConfig = this.getGatewayConfig();
+        const sessionId = this.messageManager.getSessionId();
+        const workdir = this.getWorkdir();
+        const forkMessages = [...historyMessages];
+        // Mirror the main loop's memory injection so the request prefix matches.
+        const { prependContent } = await this.messageManager.getMemoryForInjection();
+        if (prependContent.trim()) {
+            forkMessages.unshift({
+                role: "user",
+                content: wrapInSystemReminder(prependContent),
+            });
+        }
+        forkMessages.push({ role: "user", content: compactPrompt });
+        const { toolsConfig, filteredToolPlugins } = this.resolveFilteredTools();
+        const systemPrompt = await this.buildMainSystemPrompt(filteredToolPlugins);
+        let totalUsage;
+        let content;
+        for (let turn = 0; turn < MAX_FORK_TURNS; turn++) {
+            const result = await aiService.callAgent({
+                gatewayConfig,
+                modelConfig,
+                messages: forkMessages,
+                sessionId,
+                abortSignal,
+                workdir,
+                tools: toolsConfig,
+                systemPrompt,
+                toolChoice: this.toolChoiceOverride,
+                // Stream so a slow reasoning model emits first bytes before the
+                // gateway's idle timeout fires (non-streaming waits for the full
+                // summary, which exceeds the timeout on large contexts).
+                stream: true,
+            });
+            if (result.usage) {
+                totalUsage = {
+                    prompt_tokens: (totalUsage?.prompt_tokens ?? 0) + result.usage.prompt_tokens,
+                    completion_tokens: (totalUsage?.completion_tokens ?? 0) +
+                        result.usage.completion_tokens,
+                    total_tokens: (totalUsage?.total_tokens ?? 0) + result.usage.total_tokens,
+                };
+            }
+            if (result.content?.trim()) {
+                content = result.content;
+                break;
+            }
+            if (result.tool_calls && result.tool_calls.length > 0) {
+                // Deny all tool calls locally and feed the rejections back so the
+                // model gets another turn to produce the summary text.
+                forkMessages.push({
+                    role: "assistant",
+                    content: result.content ?? null,
+                    tool_calls: result.tool_calls,
+                });
+                for (const toolCall of result.tool_calls) {
+                    forkMessages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: "Tool use is not allowed during compaction",
+                    });
+                }
+                continue;
+            }
+            // Neither text nor tool calls: retrying the identical request is
+            // pointless, bail out and let the caller fail the compaction.
+            break;
+        }
+        return { content, usage: totalUsage };
+    }
     /**
      * Build post-compact context restoration content.
      * Restores file reads, working directory, plan mode, skills, and background tasks.
@@ -570,7 +687,7 @@ export class AIManager {
         // has superseded us. setIsLoading(true) here also closes the "idle but
         // previous turn not finished" race window by marking us busy immediately.
         this.turnGeneration++;
-        const myGeneration = this.turnGeneration;
+        let myGeneration = this.turnGeneration;
         this.setIsLoading(true);
         outer: while (true) {
             let shouldRestart = false;
@@ -656,19 +773,10 @@ export class AIManager {
                     // Track if assistant message has been created
                     let assistantMessageCreated = false;
                     logger?.debug("modelConfig in sendAIMessage", this.getModelConfig());
-                    const toolsConfig = this.getFilteredToolsConfig();
-                    const toolNames = new Set(toolsConfig.map((t) => t.function.name));
-                    const filteredToolPlugins = this.toolManager
-                        .getTools()
-                        .filter((t) => toolNames.has(t.name));
-                    let autoMemoryOptions;
-                    if (this.getAutoMemoryEnabled()) {
-                        const directory = this.memoryService.getAutoMemoryDirectory(this.getWorkdir());
-                        const content = await this.memoryService.getAutoMemoryContent(this.getWorkdir());
-                        autoMemoryOptions = { directory, content };
-                    }
+                    const { toolsConfig, toolNames, filteredToolPlugins } = this.resolveFilteredTools();
                     // Get memory for message-array injection (not system prompt)
                     const { prependContent } = await this.messageManager.getMemoryForInjection();
+                    const mainSystemPrompt = await this.buildMainSystemPrompt(filteredToolPlugins);
                     // Call AI service with streaming callbacks if enabled
                     const callAgentOptions = {
                         gatewayConfig: this.getGatewayConfig(),
@@ -679,14 +787,7 @@ export class AIManager {
                         workdir: this.getWorkdir(), // Pass working directory
                         tools: toolsConfig, // Pass filtered tool configuration
                         model: model, // Use passed model
-                        systemPrompt: buildSystemPrompt(this.systemPrompt, filteredToolPlugins, {
-                            workdir: this.getWorkdir(),
-                            originalWorkdir: this.getOriginalWorkdir(),
-                            language: this.getLanguage(),
-                            isSubagent: !!this.subagentType,
-                            worktreeSession: this.getWorktreeSession(),
-                            autoMemory: autoMemoryOptions,
-                        }), // Pass custom system prompt
+                        systemPrompt: mainSystemPrompt, // Pass custom system prompt
                         maxTokens: maxTokens, // Pass max tokens override
                         toolChoice: this.toolChoiceOverride, // Pass tool_choice override
                     };
@@ -694,7 +795,7 @@ export class AIManager {
                     if (prependContent.trim()) {
                         callAgentOptions.messages.unshift({
                             role: "user",
-                            content: `<system-reminder>\n${prependContent}\n</system-reminder>`,
+                            content: wrapInSystemReminder(prependContent),
                         });
                     }
                     // Task reminder: persist as meta message (conditional rules already persisted above)
@@ -1084,6 +1185,14 @@ export class AIManager {
                             });
                         }
                     }
+                    // Re-assert loading state before restarting: if this turn was
+                    // aborted, abortAIMessage already reset loading to false, and the
+                    // restart below continues the conversation — the UI must show
+                    // streaming again (cursor, stop button, ESC handling).
+                    this.setIsLoading(true);
+                    // Adopt the current (possibly abort-bumped) generation so this
+                    // continued turn's end-of-turn cleanup is not skipped as superseded.
+                    myGeneration = this.turnGeneration;
                     // Restart outer loop to process the notifications
                     shouldRestart = true;
                     turnOffset = 0;