@code-yeongyu/senpi 2026.8.13 → 2026.8.16

package/dist/core/agent-session.js

@@ -37,6 +37,7 @@ import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
+import { CODEX_RESPONSES_API } from "./extensions/builtin/service-tier.js";
 import { deriveExtensionRegistrationId } from "./extensions/builtin/tool-search/engine/marker.js";
 import { getToolSearchService } from "./extensions/builtin/tool-search/service.js";
 import { ExecuteToolError, ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
@@ -70,19 +71,48 @@ import { createAllToolDefinitions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
 import { addUsageToTotals, createUsageTotals } from "./usage-totals.js";
 const TURN_RETRY_SUPPRESSION_PREFIX = "senpi:no-turn-retry:";
+/** Format the user-attributed payload for one or more explicit skill invocations. */
+export function formatSkillInvocationPrompt(skills, userRequest) {
+    const skillBlocks = skills.map((skill) => `The user explicitly invoked the "${skill.name}" skill. Follow the instructions in <skill-instruction> as binding for this request, while respecting higher-priority instructions.\n\n<skill-instruction name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${skill.body}\n</skill-instruction>`);
+    const expandedSkills = skillBlocks.join("\n\n");
+    const trimmedRequest = userRequest?.trim();
+    return trimmedRequest ? `${expandedSkills}\n\n<user-request>\n${trimmedRequest}\n</user-request>` : expandedSkills;
+}
 /**
  * Parse a skill block from message text.
  * Returns null if the text doesn't contain a skill block.
  */
 export function parseSkillBlock(text) {
-    const match = text.match(/^<skill name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill>(?:\n\n([\s\S]+))?$/);
-    if (!match)
+    const instructionPattern = /^The user explicitly invoked the "([^"]+)" skill\. Follow the instructions in <skill-instruction> as binding for this request, while respecting higher-priority instructions\.\n\n<skill-instruction name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill-instruction>/;
+    const instructionMatch = text.match(instructionPattern);
+    if (instructionMatch) {
+        if (instructionMatch[1] !== instructionMatch[2])
+            return null;
+        let remainder = text.slice(instructionMatch[0].length);
+        while (remainder.startsWith("\n\nThe user explicitly invoked the ")) {
+            const chainedMatch = remainder.slice(2).match(instructionPattern);
+            if (!chainedMatch || chainedMatch[1] !== chainedMatch[2])
+                return null;
+            remainder = remainder.slice(chainedMatch[0].length + 2);
+        }
+        const requestMatch = remainder.match(/^\n\n<user-request>\n([\s\S]*?)\n<\/user-request>$/);
+        if (remainder && !requestMatch)
+            return null;
+        return {
+            name: instructionMatch[1],
+            location: instructionMatch[3],
+            content: instructionMatch[4],
+            userMessage: requestMatch?.[1].trim() || undefined,
+        };
+    }
+    const legacyMatch = text.match(/^<skill name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill>(?:\n\n([\s\S]+))?$/);
+    if (!legacyMatch)
         return null;
     return {
-        name: match[1],
-        location: match[2],
-        content: match[3],
-        userMessage: match[4]?.trim() || undefined,
+        name: legacyMatch[1],
+        location: legacyMatch[2],
+        content: legacyMatch[3],
+        userMessage: legacyMatch[4]?.trim() || undefined,
     };
 }
 // ============================================================================
@@ -114,6 +144,8 @@ function describeCompactionRejection(cause) {
             return "Compaction rejected: the produced summary would still overflow the model context window. Reduce context (e.g. /new, drop attachments) or switch to a larger-context model.";
         case "cancelled-by-extension":
             return "Compaction rejected: cancelled by an extension.";
+        case "external-owner":
+            return "Compaction rejected: the active provider owns compaction for this session.";
         case "circuit-breaker":
             return "Compaction rejected: the compaction circuit breaker is open after repeated failures. Wait for the cooldown and retry.";
         case "per-turn-cap":
@@ -326,6 +358,9 @@ export class AgentSession {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
+        this._unsubscribeSettingsSource = this.settingsManager.subscribeToSourceSelection((source) => {
+            this._emit({ type: "settings_source_selected", ...source });
+        });
         const noModelFallback = config.resourceLoader.getExtensions().runtime.flagValues.get("no-model-fallback") === true ||
             envValue("NO_FALLBACK") === "1";
         if (noModelFallback) {
@@ -379,6 +414,7 @@ export class AgentSession {
         });
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
+        this._defaultToolNames = config.defaultToolNames ? new Set(config.defaultToolNames) : undefined;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
         this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : undefined;
         this._baseToolsOverride = config.baseToolsOverride;
@@ -786,6 +822,13 @@ export class AgentSession {
     get agentDir() {
         return this._agentDir;
     }
+    /**
+     * Working directory this session resolves settings against — the same value extensions
+     * receive as `ctx.cwd`, so a host surface (RPC) reads project settings identically.
+     */
+    get cwd() {
+        return this._cwd;
+    }
     async _waitForSettledSessionWork() {
         await this._sessionWorkBarrier.waitForSettled(() => this._agentEventQueue);
     }
@@ -1215,7 +1258,7 @@ export class AgentSession {
                 !(requiredAutoCompaction === "threshold" && this._hasPendingPostCompactionUsageExemption(msg))) {
                 this._retireFailedRetryAssistant(msg);
                 compactedBeforeRetry = await this._runPrePromptCompaction(msg, true, "threshold", true);
-                retryContinuationBlocked = !compactedBeforeRetry;
+                retryContinuationBlocked = !compactedBeforeRetry && !this._isCompactionDelegated();
             }
             let retryOutcome = "not-handled";
             if (!retryContinuationBlocked && !userAbortSuppressedQueuedContinuation) {
@@ -1543,6 +1586,9 @@ export class AgentSession {
      */
     subscribe(listener) {
         this._eventListeners.push(listener);
+        for (const source of this.settingsManager.getSelectedSettingsSources()) {
+            listener({ type: "settings_source_selected", ...source });
+        }
         // Return unsubscribe function for this specific listener
         return () => {
             const index = this._eventListeners.indexOf(listener);
@@ -1590,6 +1636,8 @@ export class AgentSession {
         }
         this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
         this._disconnectFromAgent();
+        this._unsubscribeSettingsSource?.();
+        this._unsubscribeSettingsSource = undefined;
         this._eventListeners = [];
         cleanupSessionResources(this.sessionId);
     }
@@ -1623,13 +1671,54 @@ export class AgentSession {
     isFastModeActive() {
         return this._sessionFastMode || this._currentServiceTier === "priority";
     }
-    /** Session-scoped fast-mode indicator; never persisted, reset on session start. */
+    /**
+     * The tier a request would carry right now: `serviceTier`, promoted to `"priority"` while
+     * session fast mode is on (which is exactly what the service-tier extension puts on the
+     * wire). Reported to clients so `serviceTier` and `fastMode` can never disagree.
+     */
+    get effectiveServiceTier() {
+        return this.isFastModeActive() ? "priority" : this._currentServiceTier;
+    }
+    /**
+     * Session-scoped fast-mode indicator; never persisted, reset on session start.
+     *
+     * Turning fast OFF also clears the cached priority tier: `/fast off` writes a remembered
+     * `"auto"` that must override an inherited catalog-priority tier immediately (display and
+     * request side), not only on the next session. Only codex-response models are touched, and
+     * never when an explicit scoped/favorite `:priority` pin is in force — those are pinned by
+     * the user's model selection, not by `/fast`.
+     */
     setSessionFastMode(enabled) {
+        const previousFastMode = this.isFastModeActive();
+        const previousTier = this._currentServiceTier;
         this._sessionFastMode = enabled;
+        if (!enabled && this._currentServiceTier === "priority" && this.model?.api === CODEX_RESPONSES_API) {
+            // Only an INHERITED (catalog) priority is cleared. A priority the catalog does not
+            // explain came from an explicit scoped/favorite `:priority` pin, which `/fast` must not undo.
+            if (this._modelRuntime.getCompatibilityRequestConfig(this.model).serviceTier === "priority") {
+                this._currentServiceTier = undefined;
+            }
+        }
+        this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
+    }
+    /**
+     * Emit `service_tier_changed` when the effective tier or the fast-mode indicator actually
+     * moved. Both are observable state for RPC clients (`get_state.serviceTier` / `.fastMode`),
+     * and they can move independently: a session fast-mode toggle need not change the resolved
+     * tier, and a model switch can change the tier with fast mode untouched.
+     */
+    _emitServiceTierChangeIfNeeded(previousTier, previousFastMode) {
+        const fastMode = this.isFastModeActive();
+        if (previousTier === this._currentServiceTier && previousFastMode === fastMode)
+            return;
+        this._emit({ type: "service_tier_changed", tier: this.effectiveServiceTier, fastMode });
     }
     /**
      * Explicit scoped/favorite tiers win; otherwise fall back to the model's
-     * configured serviceTier from models.json/extension compatibility config.
+     * configured serviceTier from models.json/extension compatibility config. The per-model
+     * `/fast` memory is honored by the service-tier extension (`liveMemoryTier` + the session
+     * flag in `before_provider_request`), not cached here: caching it would survive a same-session
+     * `/fast off` (no model switch to re-resolve) and leak an inherited priority onto the wire.
      */
     _resolveServiceTier(model, explicit) {
         if (explicit)
@@ -1911,6 +2000,8 @@ export class AgentSession {
             selectedTools: validToolNames,
             toolSnippets,
             promptGuidelines,
+            customPrompt: loaderSystemPrompt,
+            appendSystemPrompt: loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join("\n\n") : undefined,
         };
         const basePrompt = loaderSystemPrompt ?? buildDynamicSystemPrompt(this._baseSystemPromptOptions);
         return loaderAppendSystemPrompt.length > 0
@@ -2304,7 +2395,12 @@ export class AgentSession {
                 try {
                     const content = readFileSync(skill.filePath, "utf-8");
                     const body = stripFrontmatter(content).trim();
-                    skillBlocks.push(`<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`);
+                    skillBlocks.push({
+                        name: skill.name,
+                        filePath: skill.filePath,
+                        baseDir: skill.baseDir,
+                        body,
+                    });
                     expandedSkillNames.add(skill.name);
                 }
                 catch (err) {
@@ -2324,8 +2420,7 @@ export class AgentSession {
         if (skillBlocks.length === 0)
             return text;
         const args = text.slice(tokenStart).trim();
-        const expandedSkills = skillBlocks.join("\n\n");
-        return args ? `${expandedSkills}\n\n${args}` : expandedSkills;
+        return formatSkillInvocationPrompt(skillBlocks, args);
     }
     /**
      * Queue a steering message while the agent is running.
@@ -2530,7 +2625,7 @@ export class AgentSession {
             if (options?.deliverAs === "nextTurn") {
                 this._pendingNextTurnMessages.push(appMessage);
             }
-            else if (this.isStreaming) {
+            else if (this.isStreaming && options?.triggerTurn !== false) {
                 if (options?.deliverAs === "followUp") {
                     this.agent.followUp(appMessage);
                 }
@@ -2591,6 +2686,7 @@ export class AgentSession {
      *
      * @param content User message content (string or content array)
      * @param options.deliverAs Delivery mode when streaming: "steer" or "followUp"
+     * @param options.expandPromptTemplates Whether to dispatch extension commands and expand skill commands and prompt templates. Default: false.
      */
     async sendUserMessage(content, options) {
         const bindingPromptReadiness = this._extensionBindingPromptReadiness;
@@ -2629,9 +2725,8 @@ export class AgentSession {
         let finishSessionWork;
         let disposition;
         try {
-            // Use prompt() with expandPromptTemplates: false to skip command handling and template expansion
             await this.prompt(text, {
-                expandPromptTemplates: false,
+                expandPromptTemplates: options?.expandPromptTemplates ?? false,
                 streamingBehavior: options?.deliverAs,
                 images,
                 source: "extension",
@@ -2838,7 +2933,7 @@ export class AgentSession {
         if (opts.invalidateCompaction && this._modelSelectionChangesContext(previousModel, model)) {
             this._invalidateCompactionForModelSelection();
         }
-        const thinkingLevel = this._getThinkingLevelForModelSwitch(opts.ephemeralThinkingLevel);
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(model, opts.ephemeralThinkingLevel);
         this.agent.state.model = model;
         this.agent.abortServerSideFallback =
             this.settingsManager.getAbortServerSideFallback() && this._retryFallback.hasConfiguredChain();
@@ -2849,6 +2944,8 @@ export class AgentSession {
             this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
         }
         const scopedMatch = this._scopedModels.find((sm) => modelsAreEqual(sm.model, model));
+        const previousTier = this._currentServiceTier;
+        const previousFastMode = this.isFastModeActive();
         this._currentServiceTier = this._resolveServiceTier(model, scopedMatch?.serviceTier);
         if (opts.ephemeralThinkingLevel !== undefined) {
             this._applyEphemeralThinkingLevel(thinkingLevel);
@@ -2857,6 +2954,15 @@ export class AgentSession {
             this.setSessionThinkingLevel(thinkingLevel);
         }
         this._emitHighReasoningWarningIfNeeded();
+        // Post-switch: the level reported here is the one actually in force (clamped, or restored
+        // from this model's memory), not the level requested for the previous model.
+        this._emit({
+            type: "model_changed",
+            model,
+            thinkingLevel: this.thinkingLevel,
+            source: opts.modelSelectSource,
+        });
+        this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
         if (!opts.emitModelSelect)
             return undefined;
         return await this._emitModelSelect(model, previousModel, opts.modelSelectSource);
@@ -2901,16 +3007,26 @@ export class AgentSession {
         }
         this._probeBackScheduler.cancel("manual-model-change");
         this._retryFallback.clearForManualModelChange(next.model);
-        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.model, next.thinkingLevel);
         this.agent.state.model = next.model;
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
         this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+        const previousTier = this._currentServiceTier;
+        const previousFastMode = this.isFastModeActive();
         this._currentServiceTier = this._resolveServiceTier(next.model, next.serviceTier);
         // Apply thinking level.
         // - Explicit favorite model thinking level overrides the effective session level
         // - Undefined favorite model thinking level restores the remembered user preference
         // setSessionThinkingLevel clamps without replacing that preference.
         this.setSessionThinkingLevel(thinkingLevel);
+        // Post-switch, same contract as _switchActiveModel: the level in force AFTER the cycle.
+        this._emit({
+            type: "model_changed",
+            model: next.model,
+            thinkingLevel: this.thinkingLevel,
+            source: "cycle",
+        });
+        this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
         const systemPromptChange = await this._emitModelSelect(next.model, currentModel, "cycle");
         const cycleResult = { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
         if (systemPromptChange) {
@@ -2924,7 +3040,7 @@ export class AgentSession {
     /**
      * Set thinking level.
      * Clamps to model capabilities based on available thinking levels.
-     * Saves to session and settings only if the level actually changes.
+     * Persistent calls refresh per-model memory; session entries and events are emitted only on change.
      */
     setThinkingLevel(level) {
         this._setThinkingLevel(level, true);
@@ -2946,6 +3062,12 @@ export class AgentSession {
             this._retryFallback.noteManualThinkingLevel();
         }
         this.agent.state.thinkingLevel = effectiveLevel;
+        if (updateGlobalDefault) {
+            const model = this.model;
+            if (model) {
+                this.settingsManager.setModelThinkingLevel(model.provider, model.id, effectiveLevel);
+            }
+        }
         if (isChanging) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel);
             if (updateGlobalDefault && (this.supportsThinking() || effectiveLevel !== "off")) {
@@ -3017,11 +3139,12 @@ export class AgentSession {
     supportsThinking() {
         return !!this.model?.reasoning;
     }
-    _getThinkingLevelForModelSwitch(explicitLevel) {
-        if (explicitLevel !== undefined) {
-            return explicitLevel;
-        }
-        return this.settingsManager.getDefaultThinkingLevel() ?? this.thinkingLevel ?? DEFAULT_THINKING_LEVEL;
+    _getThinkingLevelForModelSwitch(model, explicitLevel) {
+        const requestedLevel = explicitLevel ??
+            this.settingsManager.getModelThinkingLevel(model.provider, model.id) ??
+            this.settingsManager.getDefaultThinkingLevel() ??
+            DEFAULT_THINKING_LEVEL;
+        return this._clampThinkingLevel(requestedLevel, getSupportedThinkingLevels(model));
     }
     _clampThinkingLevel(level, availableLevels) {
         const available = new Set(availableLevels);
@@ -3685,8 +3808,9 @@ export class AgentSession {
             if (compacted)
                 return true;
         }
-        if (this._isCompactionOnCooldown())
+        if (this._isCompactionOnCooldown() || this._isCompactionDelegated() || this._hasSupersedingCompactionClaim()) {
             return false;
+        }
         throw new RequiredCompactionError();
     }
     /**
@@ -3725,6 +3849,10 @@ export class AgentSession {
             throw new RequiredCompactionError();
         }
         const compacted = await this._runPrePromptCompaction(lastAssistantMessage, false, "pre_prompt");
+        if (!compacted && this._isCompactionDelegated())
+            return;
+        if (!compacted && this._hasSupersedingCompactionClaim())
+            return;
         if (!compacted && !isOversized() && this._isCompactionOnCooldown())
             return;
         if (!compacted || isOversized()) {
@@ -3774,6 +3902,7 @@ export class AgentSession {
                 const compacted = await this._runAutoCompaction("overflow", false);
                 if (!compacted &&
                     this._compactionLifecycle.state.status === "failed" &&
+                    this._compactionLifecycle.state.rejectionCause !== "external-owner" &&
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
@@ -3814,7 +3943,7 @@ export class AgentSession {
                 this._restoreAgentMessagesFromSession();
                 this._incrementMessageRevision();
             }
-            if (!compacted && inlineReason) {
+            if (!compacted && inlineReason && !this._isCompactionDelegated() && !this._hasSupersedingCompactionClaim()) {
                 throw new RequiredCompactionError();
             }
             return compacted;
@@ -3867,6 +3996,7 @@ export class AgentSession {
                 const compacted = await this._runAutoCompaction("threshold", retryAfterCompaction);
                 if (!compacted &&
                     this._compactionLifecycle.state.status === "failed" &&
+                    this._compactionLifecycle.state.rejectionCause !== "external-owner" &&
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
@@ -3882,6 +4012,26 @@ export class AgentSession {
         const state = this._compactionLifecycle.state;
         return state.status === "failed" && state.rejectionCause === "circuit-breaker";
     }
+    /**
+     * Compaction claims are last-writer-wins: a newer admission aborts the
+     * incumbent controller (_claimCompactionController). When the failed attempt
+     * lost that race, a live claimant now owns the route and re-gates admission
+     * itself, so the loser must not surface RequiredCompactionError (issue #886).
+     * A user abort leaves no live claimant behind and keeps throwing.
+     */
+    _hasSupersedingCompactionClaim() {
+        const claimant = this._compactionAbortController ?? this._autoCompactionAbortController;
+        return claimant !== undefined && !claimant.signal.aborted;
+    }
+    _isCompactionDelegated() {
+        const state = this._compactionLifecycle.state;
+        const model = this.model;
+        return (state.status === "failed" &&
+            state.rejectionCause === "external-owner" &&
+            state.model !== undefined &&
+            model !== undefined &&
+            state.model.provider === model.provider);
+    }
     async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false, allowSummaryOnly = false) {
         const controller = new AbortController();
         const requestId = randomUUID();
@@ -3946,8 +4096,9 @@ export class AgentSession {
             return;
         const compacted = await this._runPrePromptCompaction(this._findLastAssistantMessage(), true, "pre_prompt");
         if (!compacted) {
-            if (this._isCompactionOnCooldown())
+            if (this._isCompactionOnCooldown() || this._isCompactionDelegated() || this._hasSupersedingCompactionClaim()) {
                 return;
+            }
             throw new RequiredCompactionError();
         }
         this._scheduledContinuationRecompacted = true;
@@ -4193,6 +4344,7 @@ export class AgentSession {
             this._applyExtensionBindings(this._extensionRunner);
             this.syncPromptCacheSafeWaitEnv();
             await this._extensionRunner.emit(this._sessionStartEvent);
+            this._enforceConfiguredDefaultTools();
             await this.extendResourcesFromExtensions(this._sessionStartEvent.reason === "reload" ? "reload" : "startup");
         }
         finally {
@@ -4526,6 +4678,22 @@ export class AgentSession {
     get fallbackValidationWarnings() {
         return this._fallbackValidationWarnings;
     }
+    _isBuiltinExtensionPath(path) {
+        return path.startsWith("<builtin:") || /[\\/]senpi-codemode[\\/]/u.test(path);
+    }
+    _enforceConfiguredDefaultTools() {
+        const defaultToolNames = this._defaultToolNames;
+        if (defaultToolNames === undefined)
+            return;
+        this.setActiveToolsByName(this.getActiveToolNames().filter((name) => {
+            if (defaultToolNames.has(name))
+                return true;
+            const entry = this._toolDefinitions.get(name);
+            return (entry !== undefined &&
+                !this._isBuiltinExtensionPath(entry.sourceInfo.path) &&
+                entry.sourceInfo.source !== "builtin");
+        }));
+    }
     _refreshToolRegistry(options) {
         const previousRegistryNames = new Set(this._toolRegistry.keys());
         const previousActiveToolNames = this.getActiveToolNames();
@@ -4533,8 +4701,12 @@ export class AgentSession {
         const excludedToolNames = this._excludedToolNames;
         const isAllowedTool = (name) => (!allowedToolNames || allowedToolNames.has(name)) && !excludedToolNames?.has(name);
         const registeredTools = this._extensionRunner.getAllRegisteredTools();
+        const defaultToolNames = this._defaultToolNames;
+        const isConfiguredBuiltinTool = (tool) => (tool.sourceInfo.source !== "builtin" && !this._isBuiltinExtensionPath(tool.sourceInfo.path)) ||
+            defaultToolNames === undefined ||
+            defaultToolNames.has(tool.definition.name);
         const allCustomTools = [
-            ...registeredTools,
+            ...registeredTools.filter(isConfiguredBuiltinTool),
             ...this._customTools.map((definition) => ({
                 definition,
                 sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }),
@@ -5177,7 +5349,10 @@ export class AgentSession {
             model &&
             shouldCompact(contextTokens, model.contextWindow, compactionSettings)) {
             const preRetryCompaction = await this._runPrePromptCompaction(message, true, "threshold", true, true);
-            if (!preRetryCompaction && !this._isCompactionOnCooldown()) {
+            if (!preRetryCompaction &&
+                !this._isCompactionOnCooldown() &&
+                !this._isCompactionDelegated() &&
+                !this._hasSupersedingCompactionClaim()) {
                 const attempt = this._retryAttempt;
                 this._retryAttempt = 0;
                 this._resetHintTierState();
@@ -5666,11 +5841,11 @@ export class AgentSession {
     /**
      * Export session to HTML.
      * @param outputPath Optional output path (defaults to session directory)
+     * @param options Optional export presentation settings
      * @returns Path to exported file
      */
-    async exportToHtml(outputPath) {
-        const configuredThemeName = this.settingsManager.getTheme();
-        const themeName = configuredThemeName && getThemeByName(configuredThemeName) ? configuredThemeName : undefined;
+    async exportToHtml(outputPath, options = {}) {
+        const themeName = [options.themeName, this.settingsManager.getTheme()].find((candidate) => candidate !== undefined && getThemeByName(candidate) !== undefined);
         // Create tool renderer if we have an extension runner (for custom tool HTML rendering)
         const toolRenderer = createToolHtmlRenderer({
             getToolDefinition: (name) => this.getToolDefinition(name),