@code-yeongyu/senpi 2026.9.9 → 2026.9.10-2

package/dist/core/agent-session.js

@@ -39,11 +39,14 @@ import { isTurnStuckOnContextOverflow } from "./compaction/stuck-overflow.js";
 import { isWarmSummaryAnchorValid } from "./compaction/warm-anchor.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
+import { AssistantEditError, assertExpectedLeaf, assistantTextEquals, buildEditedAssistantMessage, SessionStreamingError, } from "./edited-assistant-message.js";
 import { areExperimentalFeaturesEnabled } from "./experimental.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ModelUsabilityBudgetError, projectModelUsabilityBudget, } from "./extensions/builtin/compaction/model-usability-budget.js";
 import { resolveEffectiveReserveTokens, resolveReserveTokens, shouldTriggerCompaction, } from "./extensions/builtin/compaction/policy.js";
+import { createResumeCompactionRequirement, } from "./extensions/builtin/compaction/resume-admission.js";
+import { RESUME_SLICE_ORIGIN, RESUME_SLICE_SCHEMA, resumeSliceNotice, } from "./extensions/builtin/compaction/resume-slice.js";
 import { WAKE_SOURCE_STATE_EVENT } from "./extensions/builtin/monitor-state-event.js";
 import { CODEX_RESPONSES_API } from "./extensions/builtin/service-tier.js";
 import { deriveExtensionRegistrationId } from "./extensions/builtin/tool-search/engine/marker.js";
@@ -52,7 +55,7 @@ import { ExecuteToolError, ExtensionRunner, wrapRegisteredTools, } from "./exten
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { normalizeToolExposure, RUNTIME_EXTENSION_PATH } from "./extensions/types.js";
 import { shouldWarnHighReasoning } from "./high-reasoning-warning.js";
-import { MANUAL_CONTINUE_CUSTOM_TYPE, MANUAL_CONTINUE_DIRECTIVE } from "./manual-continue.js";
+import { isManualContinueSubmission, MANUAL_CONTINUE_CUSTOM_TYPE, MANUAL_CONTINUE_DIRECTIVE, } from "./manual-continue.js";
 import { convertToLlm, filterContextExcludedMessages, } from "./messages.js";
 import { ModelRegistry } from "./model-registry.js";
 import { getModelNarrowingPatterns, resolveModelScope } from "./model-resolver.js";
@@ -618,6 +621,9 @@ export class AgentSession {
         if (noModelFallback) {
             this.settingsManager.applyOverrides({ retry: { modelFallback: false } });
         }
+        if (config.resourceLoader.getExtensions().runtime.flagValues.get("no-ask-user") === true) {
+            this.settingsManager.applyOverrides({ askUser: { enabled: false } });
+        }
         this._scopedModels = config.scopedModels ?? [];
         this._favoriteModels = config.favoriteModels ?? [];
         this._resourceLoader = config.resourceLoader;
@@ -2072,6 +2078,16 @@ export class AgentSession {
      */
     subscribe(listener) {
         this._eventListeners.push(listener);
+        if (this._resumeCompactionRequirement !== undefined) {
+            listener({
+                type: "resume_compaction_required",
+                projection: this._resumeCompactionRequirement.projection,
+                notice: this._resumeCompactionRequirement.notice,
+            });
+        }
+        if (this._resumeSlice !== undefined) {
+            listener(this._resumeSliceEvent(this._resumeSlice));
+        }
         for (const source of this.settingsManager.getSelectedSettingsSources()) {
             listener({ type: "settings_source_selected", ...source });
         }
@@ -2331,6 +2347,7 @@ export class AgentSession {
         let isError = false;
         try {
             result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, options?.signal, options?.onUpdate);
+            isError = result.isError === true;
         }
         catch (err) {
             result = {
@@ -2774,7 +2791,11 @@ export class AgentSession {
             // empty session, or a "." carrying image attachments (the user is sending
             // the images, not asking to continue), falls through to ordinary prompt
             // handling below.
-            if (text.trim() === "." && this.agent.state.messages.length > 0 && !options?.images?.length) {
+            if (isManualContinueSubmission({
+                text,
+                hasMessages: this.agent.state.messages.length > 0,
+                hasImages: (options?.images?.length ?? 0) > 0,
+            })) {
                 await this.sendCustomMessage({
                     customType: MANUAL_CONTINUE_CUSTOM_TYPE,
                     content: MANUAL_CONTINUE_DIRECTIVE,
@@ -3706,6 +3727,34 @@ export class AgentSession {
         if (!projection.usable)
             throw new ModelUsabilityBudgetError(projection);
     }
+    /** Admit an oversized restored transcript so the normal pre-provider compaction can run. */
+    admitResumeCompactionRequired(projection) {
+        this._resumeCompactionRequirement = createResumeCompactionRequirement(projection);
+    }
+    /** Reduce an over-window restored context deterministically while the recorded transcript stays intact. */
+    applyResumeSlice(plan) {
+        this.sessionManager.appendCompaction(plan.summary, plan.firstKeptEntryId, plan.tokensBefore, {
+            schema: RESUME_SLICE_SCHEMA,
+            origin: RESUME_SLICE_ORIGIN,
+        });
+        this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+        this._resumeSlice = plan;
+        this._sessionLogger.info("resume_context_reduced", {
+            count: plan.droppedEntries,
+            tokensBefore: plan.tokensBefore,
+            tokensAfter: plan.tokensAfter,
+        });
+        this._emit(this._resumeSliceEvent(plan));
+    }
+    _resumeSliceEvent(plan) {
+        return {
+            type: "resume_context_reduced",
+            tokensBefore: plan.tokensBefore,
+            tokensAfter: plan.tokensAfter,
+            droppedEntries: plan.droppedEntries,
+            notice: resumeSliceNotice(plan),
+        };
+    }
     _getDownswitchLiveContextTokens(model) {
         const currentModel = this.model;
         if (!currentModel)
@@ -3737,10 +3786,67 @@ export class AgentSession {
     async setSessionModel(model) {
         return this._setModel(model, false);
     }
+    /**
+     * #1526: every switch guard rejects before `_switchActiveModel` appends its
+     * `model_change`, so a refused switch used to leave no entry, no event, and
+     * no log line - indistinguishable from a switch the user never attempted.
+     * Record the refusal, then rethrow the original error unchanged.
+     */
+    _recordRejectedModelChange(model, error) {
+        const budget = error instanceof ModelUsabilityBudgetError ? error.projection : undefined;
+        const detail = error instanceof Error ? error.message : String(error);
+        const reason = budget ? "context-budget" : "auth";
+        const numbers = budget
+            ? {
+                contextWindow: budget.contextWindow,
+                liveContextTokens: budget.liveContextTokens,
+                requiredTokens: budget.requiredTokens,
+                shortfallTokens: budget.shortfallTokens,
+                safetyMarginProfile: budget.safetyMarginProfile,
+            }
+            : {};
+        this.sessionManager.appendModelChangeRejected({
+            provider: model.provider,
+            modelId: model.id,
+            reason,
+            detail,
+            ...numbers,
+        });
+        this._emit({ type: "model_change_rejected", model, reason, detail, ...numbers });
+    }
+    /**
+     * The admission only selects wording, and the switch wording's remedy
+     * ("Compact the session, ...") is executable only when there is context to
+     * compact. `_setModel` is also reachable from `session_start` (the
+     * `recommended-models` builtin switches the model there), so derive the
+     * admission from the branch instead of hardcoding a switch: with conversation
+     * context this is a switch, on an empty session it is still a cold start.
+     */
+    _modelSwitchAdmission() {
+        return this.sessionManager.hasContextMessages() ? "switch" : "start";
+    }
+    /**
+     * The single guard seam for a model switch (#1526): every site that can
+     * refuse a switch - the `_setModel` pre-flight, the post-`model_select`
+     * revalidation in `_switchActiveModel`, and both cycle guards - records the
+     * refusal and rethrows the original error unchanged, so no refusal is
+     * observable on one path and invisible on its sibling.
+     */
+    _assertModelUsableForSwitch(model, liveContextTokens) {
+        try {
+            this.assertModelUsable(model, liveContextTokens, { admission: this._modelSwitchAdmission() });
+        }
+        catch (error) {
+            this._recordRejectedModelChange(model, error);
+            throw error;
+        }
+    }
     async _setModel(model, updateGlobalDefaults) {
-        this.assertModelUsable(model, this._getDownswitchLiveContextTokens(model));
+        this._assertModelUsableForSwitch(model, this._getDownswitchLiveContextTokens(model));
         if (!(await this._modelRuntime.checkAuth(model.provider))) {
-            throw new Error(`No API key for ${model.provider}/${model.id}`);
+            const error = new Error(`No API key for ${model.provider}/${model.id}`);
+            this._recordRejectedModelChange(model, error);
+            throw error;
         }
         // A manual model change abandons any active fallback window; if a fallback
         // retry sleep is still pending, cancel it so no surprise continuation fires.
@@ -3814,7 +3920,7 @@ export class AgentSession {
             const systemPromptChange = opts.emitModelSelect
                 ? await this._emitModelSelect(model, previousModel, opts.modelSelectSource)
                 : undefined;
-            this.assertModelUsable(model, liveContextTokens);
+            this._assertModelUsableForSwitch(model, liveContextTokens);
             if (opts.appendSessionEntry) {
                 this.sessionManager.appendModelChange(model.provider, model.id, opts.entryReason, previousModel?.provider, previousModel?.id);
             }
@@ -3914,7 +4020,7 @@ export class AgentSession {
             const alternatives = favoriteModels.filter((entry) => !modelsAreEqual(entry.model, currentModel));
             const onlyAlternative = alternatives.length === 1 ? alternatives[0] : undefined;
             if (onlyAlternative) {
-                this.assertModelUsable(onlyAlternative.model, this._getDownswitchLiveContextTokens(onlyAlternative.model));
+                this._assertModelUsableForSwitch(onlyAlternative.model, this._getDownswitchLiveContextTokens(onlyAlternative.model));
             }
             return {
                 model: currentModel,
@@ -3925,7 +4031,7 @@ export class AgentSession {
         }
         const next = favoriteModels[selectedIndex];
         const liveContextTokens = this._getDownswitchLiveContextTokens(next.model);
-        this.assertModelUsable(next.model, liveContextTokens);
+        this._assertModelUsableForSwitch(next.model, liveContextTokens);
         const invalidatesCompaction = this._modelSelectionChangesContext(currentModel, next.model) ||
             currentModel?.provider !== next.model.provider ||
             currentModel?.id !== next.model.id;
@@ -3936,25 +4042,30 @@ export class AgentSession {
         this._retryFallback.clearForManualModelChange(next.model);
         const thinking = this._getThinkingForModelSwitch(next.model, next.thinkingLevel, next.thinkingSelection);
         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 and provenance from the favorite projection or remembered preference.
         this._setThinkingLevel(thinking.level, false, thinking.selection);
-        // 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 previousSystemPrompt = this.agent.state.systemPrompt;
         try {
             const systemPromptChange = await this._emitModelSelect(next.model, currentModel, "cycle");
-            this.assertModelUsable(next.model, liveContextTokens);
+            // #1526: the `model_select` hook may have grown the system prompt, so the
+            // switch is not decided yet. Nothing durable - no `model_change`, no global
+            // default - may be written before this guard accepts, or a refused cycle
+            // would resume on a model that never ran (the ordering `_switchActiveModel`
+            // already uses).
+            this._assertModelUsableForSwitch(next.model, liveContextTokens);
+            this.sessionManager.appendModelChange(next.model.provider, next.model.id);
+            this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+            // 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 cycleResult = {
                 model: next.model,
                 thinkingLevel: this.thinkingLevel,
@@ -3972,6 +4083,7 @@ export class AgentSession {
             else
                 delete this.agent.state.model;
             this.agent.state.systemPrompt = previousSystemPrompt;
+            this._currentServiceTier = previousTier;
             throw error;
         }
     }
@@ -4899,6 +5011,27 @@ export class AgentSession {
         }
         const settings = this._getCompactionSettings();
         const model = this.model;
+        if (this._resumeCompactionRequirement !== undefined) {
+            if (!model)
+                throw new RequiredCompactionError();
+            const compacted = await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason);
+            if (!compacted)
+                throw new RequiredCompactionError();
+            const currentContext = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
+            const remainingProjection = projectModelUsabilityBudget({
+                model,
+                systemPrompt: this.agent.state.systemPrompt,
+                tools: this.agent.state.tools,
+                liveContextTokens: currentContext,
+                compaction: settings,
+                includeSpeculationLead: false,
+                admission: "resume",
+            });
+            if (!remainingProjection.usable)
+                throw new RequiredCompactionError();
+            this._resumeCompactionRequirement = undefined;
+            return true;
+        }
         const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
         const compacted = assistantMessage
             ? await this._checkCompaction(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction)
@@ -5803,6 +5936,7 @@ export class AgentSession {
                     models: project?.models ?? global?.models,
                 };
             },
+            getAskUserSettings: () => this.settingsManager.getAskUserSettings(),
             getImageSettings: () => ({
                 autoResize: this.settingsManager.getImageAutoResize(),
                 blockImages: this.settingsManager.getBlockImages(),
@@ -7015,12 +7149,43 @@ export class AgentSession {
      * @returns Result with editorText (if user message) and cancelled status
      */
     async navigateTree(targetId, options = {}) {
+        return this._navigateTree(targetId, options);
+    }
+    /**
+     * Replace an assistant response with an edited copy. The leaf moves to the target's parent and
+     * the edited message is appended there as the new leaf, so the original and everything after it
+     * are abandoned exactly like a tree navigation (branch summary optional, `session_before_tree`
+     * and `session_tree` fire). Unchanged text appends nothing.
+     */
+    async editAssistantMessage(entryId, text, options = {}) {
+        if (this.isStreaming) {
+            throw new SessionStreamingError();
+        }
+        // Stale tokens fail before the unchanged short-circuit: a stale window never learns "unchanged".
+        assertExpectedLeaf(options.expectedLeafId, this.sessionManager.getLeafId());
+        const targetEntry = this.sessionManager.getEntry(entryId);
+        if (!targetEntry) {
+            throw new AssistantEditError("not-found", `Entry ${entryId} not found`);
+        }
+        if (targetEntry.type !== "message" || targetEntry.message.role !== "assistant") {
+            throw new AssistantEditError("not-assistant", `Entry ${entryId} is not an assistant message`);
+        }
+        // Build first so an empty replacement is rejected even when the original carries no text.
+        const replacement = buildEditedAssistantMessage(targetEntry.message, text);
+        if (assistantTextEquals(targetEntry.message, text)) {
+            return { cancelled: false, unchanged: true };
+        }
+        return this._navigateTree(entryId, options, replacement);
+    }
+    async _navigateTree(targetId, options, replacement) {
         if (this.isStreaming) {
-            throw new Error("Wait for the current response to finish before navigating the session tree.");
+            throw new SessionStreamingError();
         }
         const oldLeafId = this.sessionManager.getLeafId();
-        // No-op if already at target
-        if (targetId === oldLeafId) {
+        // Stale tokens fail even for a would-be no-op, before any extension hears about the navigation.
+        assertExpectedLeaf(options.expectedLeafId, oldLeafId);
+        // No-op if already at target (a replacement of the leaf itself still has work to do)
+        if (targetId === oldLeafId && !replacement) {
             return { cancelled: false };
         }
         // Model required for summarization
@@ -7122,7 +7287,11 @@ export class AgentSession {
             // Determine the new leaf position based on target type
             let newLeafId;
             let editorText;
-            if (targetEntry.type === "message" && targetEntry.message.role === "user") {
+            if (replacement) {
+                // Edited assistant message: leaf = parent, the edited copy is appended below
+                newLeafId = targetEntry.parentId;
+            }
+            else if (targetEntry.type === "message" && targetEntry.message.role === "user") {
                 // User message: leaf = parent (null if root), text goes to editor
                 newLeafId = targetEntry.parentId;
                 editorText = contentText(targetEntry.message.content, "");
@@ -7156,9 +7325,10 @@ export class AgentSession {
                 // No summary, navigating to non-root
                 this.sessionManager.branch(newLeafId);
             }
+            const editedEntryId = replacement ? this.sessionManager.appendMessage(replacement) : undefined;
             // Attach label to target entry when not summarizing (no summary entry to label)
             if (label && !summaryText) {
-                this.sessionManager.appendLabelChange(targetId, label);
+                this.sessionManager.appendLabelChange(editedEntryId ?? targetId, label);
             }
             // Update agent state (preserving exact messages still awaiting persistence)
             this._restoreAgentMessagesFromSession();
@@ -7173,7 +7343,7 @@ export class AgentSession {
                 fromExtension: summaryText ? fromExtension : undefined,
             });
             // Emit to custom tools
-            return { editorText, cancelled: false, summaryEntry };
+            return { editorText, cancelled: false, summaryEntry, entryId: editedEntryId };
         }
         finally {
             this._branchSummaryAbortController = undefined;