@code-yeongyu/senpi 2026.8.3 → 2026.8.4

package/dist/core/agent-session.js

@@ -207,6 +207,7 @@ export class AgentSession {
         /** Recovery-only order across both native queue modes and TUI compaction ownership. */
         this._queuedInputOrder = [];
         this._nextQueuedInputOrder = 0;
+        this._supersededCompactionLogAttemptIds = new Set();
         /** Messages queued to be included with the next user prompt as context ("asides"). */
         this._pendingNextTurnMessages = [];
         // Queues held while the first post-compaction response is classified. Agent
@@ -313,7 +314,6 @@ export class AgentSession {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
-        this.agent.abortServerSideFallback = this.settingsManager.getAbortServerSideFallback();
         const noModelFallback = config.resourceLoader.getExtensions().runtime.flagValues.get("no-model-fallback") === true ||
             process.env.SENPI_NO_FALLBACK === "1";
         if (noModelFallback) {
@@ -334,8 +334,11 @@ export class AgentSession {
         const fallbackLogger = createFallbackLogger(this._agentDir);
         this._sessionLogger = createSessionLogger(this._agentDir);
         this._fallbackValidationWarnings = validateFallbackChains(this.settingsManager.getRawFallbackChains(), this._modelRegistry);
+        // `source` names the scope that supplied the chains so a single log line
+        // points at the file to open; "default" means no scope configured any.
+        const fallbackChainsSource = this.settingsManager.getFallbackChainsScope() ?? "default";
         for (const warning of this._fallbackValidationWarnings) {
-            fallbackLogger.warn("validation_warning", { warning });
+            fallbackLogger.warn("validation_warning", { warning, source: fallbackChainsSource });
         }
         this._selectorCooldowns = new SelectorCooldowns(config.fallbackNow ?? (() => Date.now()));
         this._fallbackNow = config.fallbackNow ?? (() => Date.now());
@@ -569,8 +572,11 @@ export class AgentSession {
                     return await this._enforceCompactionBeforeProvider(turn.message, true, "threshold");
                 }
                 catch (error) {
-                    if (error instanceof RequiredCompactionError && this.agent.hasQueuedMessages()) {
-                        this._requiredCompactionAdmissionError = error;
+                    if (error instanceof RequiredCompactionError) {
+                        this._requiredCompactionTurnError = error;
+                        if (this.agent.hasQueuedMessages()) {
+                            this._requiredCompactionAdmissionError = error;
+                        }
                     }
                     throw error;
                 }
@@ -633,18 +639,76 @@ export class AgentSession {
     /** Mirror stuck-prone lifecycle transitions into logs/session.log (content-free). */
     _logSessionEvent(event) {
         if (event.type === "compaction_start") {
-            this._sessionLogger.info("compaction_start", { reason: event.reason });
+            const previousAttempt = this._activeCompactionLogAttempt;
+            if (previousAttempt) {
+                const tokensAfter = this._estimateCompactionLogTokens("persisted");
+                this._sessionLogger.info("compaction_decision", {
+                    attemptId: previousAttempt.id,
+                    reason: previousAttempt.reason,
+                    mode: previousAttempt.reason === "manual" ? "manual" : "auto",
+                    action: "compact",
+                    disposition: "superseded",
+                    accepted: false,
+                    skipped: true,
+                    aborted: true,
+                    willRetry: false,
+                    tokensBefore: previousAttempt.tokensBefore,
+                    tokensAfter,
+                });
+                this._supersededCompactionLogAttemptIds.add(previousAttempt.id);
+            }
+            const attempt = {
+                id: event.requestId ?? randomUUID(),
+                reason: event.reason,
+                tokensBefore: this._estimateCompactionLogTokens("persisted"),
+            };
+            this._activeCompactionLogAttempt = attempt;
+            this._sessionLogger.info("compaction_start", {
+                attemptId: attempt.id,
+                reason: event.reason,
+                mode: event.reason === "manual" ? "manual" : "auto",
+                action: "compact",
+                tokensBefore: attempt.tokensBefore,
+            });
             return;
         }
         if (event.type === "compaction_end") {
+            if (event.requestId && this._supersededCompactionLogAttemptIds.delete(event.requestId))
+                return;
+            const activeAttempt = this._activeCompactionLogAttempt;
+            const attempt = event.requestId !== undefined && activeAttempt?.id === event.requestId ? activeAttempt : undefined;
+            const accepted = event.accepted ?? event.result !== undefined;
+            const rejected = event.rejectionCause !== undefined;
+            const skipped = !accepted && (attempt === undefined || (!rejected && !event.aborted && !event.errorMessage));
+            const disposition = accepted
+                ? "committed"
+                : attempt === undefined
+                    ? "skipped"
+                    : rejected
+                        ? "rejected"
+                        : event.aborted
+                            ? "aborted"
+                            : event.errorMessage
+                                ? "failed"
+                                : "skipped";
+            const tokensAfter = this._estimateCompactionLogTokens(accepted ? "active" : "persisted");
             this._sessionLogger.info("compaction_decision", {
+                attemptId: attempt?.id ?? event.requestId,
                 reason: event.reason,
-                accepted: event.accepted ?? event.result !== undefined,
+                mode: event.reason === "manual" ? "manual" : "auto",
+                action: accepted || attempt ? "compact" : "none",
+                disposition,
+                accepted,
+                skipped,
                 aborted: event.aborted,
                 willRetry: event.willRetry,
                 rejectionCause: event.rejectionCause,
                 error: event.errorMessage,
+                tokensBefore: attempt?.tokensBefore ?? tokensAfter,
+                tokensAfter,
             });
+            if (attempt)
+                this._activeCompactionLogAttempt = undefined;
             return;
         }
         if (event.type === "message_end" && event.message.role === "assistant") {
@@ -659,6 +723,15 @@ export class AgentSession {
             this._sessionLogger.warn("provider_error", { kind, error: message.errorMessage });
         }
     }
+    _estimateCompactionLogTokens(source) {
+        try {
+            const messages = source === "active" ? this.agent.state.messages : this.sessionManager.buildSessionContext().messages;
+            return estimateMessagesTokens(filterContextExcludedMessages(messages));
+        }
+        catch {
+            return undefined;
+        }
+    }
     _emitQueueUpdate() {
         this._emit({
             type: "queue_update",
@@ -737,6 +810,8 @@ export class AgentSession {
     async _promptAgent(messages) {
         this._isAgentRunActive = true;
         this._requiredCompactionAdmissionError = undefined;
+        this.agent.abortServerSideFallback =
+            this.settingsManager.getAbortServerSideFallback() && this._retryFallback.hasConfiguredChain();
         try {
             await this.agent.prompt(messages);
             // AgentSession's subscriber intentionally queues event work instead of
@@ -864,14 +939,17 @@ export class AgentSession {
             const messages = filterContextExcludedMessages(this.agent.state.messages);
             const estimate = estimateContextTokens(messages);
             if (estimate.lastUsageIndex === null) {
-                return undefined;
+                if (!this._isRequiredCompactionError(message))
+                    return undefined;
             }
-            const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-            const usageMessage = messages[estimate.lastUsageIndex];
-            if (compactionEntry &&
-                usageMessage?.role === "assistant" &&
-                this._isAssistantFromBeforeLatestCompaction(usageMessage)) {
-                return undefined;
+            else {
+                const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
+                const usageMessage = messages[estimate.lastUsageIndex];
+                if (compactionEntry &&
+                    usageMessage?.role === "assistant" &&
+                    this._isAssistantFromBeforeLatestCompaction(usageMessage)) {
+                    return undefined;
+                }
             }
             contextTokens = estimate.tokens;
         }
@@ -926,14 +1004,18 @@ export class AgentSession {
         return true;
     }
     _willRetryAfterAgentEnd(messages) {
-        const settings = this.settingsManager.getRetrySettings();
-        if (!settings.enabled) {
-            return false;
-        }
         const lastAssistant = this._lastAssistantMessage ?? this._findLastAssistantInMessages(messages);
         if (!lastAssistant) {
             return false;
         }
+        if (this._isRequiredCompactionError(lastAssistant) &&
+            this._getRequiredAutoCompactionReason(lastAssistant) !== undefined) {
+            return true;
+        }
+        const settings = this.settingsManager.getRetrySettings();
+        if (!settings.enabled) {
+            return false;
+        }
         const retryableError = this._isRetryableError(lastAssistant);
         if (!retryableError && this._isHardErrorFallbackEligible(lastAssistant)) {
             return true;
@@ -957,7 +1039,15 @@ export class AgentSession {
         }
         return this._retryFallback.canTryFallback();
     }
+    _isRequiredCompactionError(message) {
+        return (this._requiredCompactionTurnError !== undefined &&
+            message.stopReason === "error" &&
+            message.errorMessage === this._requiredCompactionTurnError.message);
+    }
     async _processAgentEvent(event, signal) {
+        if (event.type === "agent_start") {
+            this._requiredCompactionTurnError = undefined;
+        }
         // When a user message starts, check if it's from either queue and remove it BEFORE emitting
         // This ensures the UI sees the updated queue state
         if (event.type === "message_start" && event.message.role === "user") {
@@ -1059,6 +1149,7 @@ export class AgentSession {
             this._lastAssistantMessage = undefined;
             this._skipNextPostRetryCompactionCheck = false;
             const requiredAutoCompaction = this._getRequiredAutoCompactionReason(msg);
+            const retryAfterRequiredCompaction = requiredAutoCompaction !== undefined && this._isRequiredCompactionError(msg);
             // Retry transient failures normally and eligible hard errors only through a fallback.
             const retryableError = this._isRetryableError(msg);
             const hardErrorFallbackEligible = this._isHardErrorFallbackEligible(msg);
@@ -1086,11 +1177,20 @@ export class AgentSession {
             retryContinuationBlocked ||= retryOutcome === "blocked";
             if (!retryContinuationBlocked) {
                 if (compactedBeforeRetry && this.agent.hasQueuedMessages()) {
+                    // Accepted recovery supersedes the stored admission rejection: the
+                    // queued continuation is about to run, so the originating prompt must
+                    // not observe the stale RequiredCompactionError.
+                    this._requiredCompactionAdmissionError = undefined;
                     this._scheduleContinuationAfterCurrentEvent();
                     launchedContinuation = true;
                 }
                 else {
-                    launchedContinuation = await this._checkCompaction(msg);
+                    launchedContinuation = await this._checkCompaction(msg, true, undefined, retryAfterRequiredCompaction);
+                    if (launchedContinuation && this.agent.hasQueuedMessages()) {
+                        // Same supersession on the post-check path: an accepted recovery
+                        // compaction owns the continuation now.
+                        this._requiredCompactionAdmissionError = undefined;
+                    }
                     allowsPostCompactionUsageExemptContinuation = this._postCompactionUsageExemptAssistants.has(msg);
                     if (allowsPostCompactionUsageExemptContinuation) {
                         this._flushPostCompactionDeferredMessages();
@@ -1113,6 +1213,9 @@ export class AgentSession {
                 !retryContinuationBlocked &&
                 (allowsQueuedContinuation || allowsPostCompactionUsageExemptContinuation) &&
                 this.agent.hasQueuedMessages()) {
+                // A scheduled continuation owns the queue now; the stored admission
+                // rejection from a superseded required compaction must not surface.
+                this._requiredCompactionAdmissionError = undefined;
                 this._scheduleContinuationAfterCurrentEvent();
                 launchedContinuation = true;
             }
@@ -2647,6 +2750,8 @@ export class AgentSession {
         }
         const thinkingLevel = this._getThinkingLevelForModelSwitch(opts.ephemeralThinkingLevel);
         this.agent.state.model = model;
+        this.agent.abortServerSideFallback =
+            this.settingsManager.getAbortServerSideFallback() && this._retryFallback.hasConfiguredChain();
         if (opts.appendSessionEntry) {
             this.sessionManager.appendModelChange(model.provider, model.id, opts.entryReason, previousModel?.provider, previousModel?.id);
         }
@@ -2966,6 +3071,7 @@ export class AgentSession {
     async compact(customInstructions) {
         const admission = this._claimPendingCompactionAdmission();
         const controller = admission.controller;
+        const requestId = randomUUID();
         let outcome = "failed";
         let disconnected = false;
         try {
@@ -2975,11 +3081,12 @@ export class AgentSession {
             await this._abortActiveAgentAndRetry("system");
             this._disconnectFromAgent();
             disconnected = true;
-            this._emit({ type: "compaction_start", reason: "manual" });
+            this._emit({ type: "compaction_start", reason: "manual", requestId });
             const execution = await this._executeCompaction({
                 controller,
                 owner: "compaction",
                 reason: "manual",
+                requestId,
                 customInstructions,
                 willRetry: false,
             });
@@ -3005,6 +3112,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
             });
             throw error;
@@ -3028,9 +3136,13 @@ export class AgentSession {
             return { applied: false, reason: "stale" };
         }
         const ownsController = this._compactionAbortController === undefined;
+        const lifecycleState = this._compactionLifecycle.state;
+        const requestId = !ownsController && lifecycleState.status === "running" && lifecycleState.stage === "feedback"
+            ? lifecycleState.operationId
+            : randomUUID();
         if (ownsController) {
             this._claimCompactionController(new AbortController(), "compaction");
-            this._emit({ type: "compaction_start", reason: options.reason });
+            this._emit({ type: "compaction_start", reason: options.reason, requestId });
         }
         const controller = this._compactionAbortController;
         if (!controller)
@@ -3041,6 +3153,7 @@ export class AgentSession {
                 controller,
                 owner: "compaction",
                 reason: options.reason,
+                requestId,
                 willRetry: false,
                 precomputed,
             });
@@ -3062,6 +3175,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
             });
             return { applied: false, reason: "rejected" };
@@ -3076,14 +3190,15 @@ export class AgentSession {
         const controller = new AbortController();
         this._claimCompactionController(controller, "compaction");
         const model = this.model;
+        const requestId = randomUUID();
         this._compactionLifecycle.begin({
-            operationId: randomUUID(),
+            operationId: requestId,
             stage: "feedback",
             reason,
             model: model ? { provider: model.provider, id: model.id } : undefined,
             startedRevision: this._messageRevision,
         }, controller);
-        this._emit({ type: "compaction_start", reason });
+        this._emit({ type: "compaction_start", reason, requestId });
         return controller.signal;
     }
     _updateExtensionCompactionFeedback(options) {
@@ -3121,7 +3236,8 @@ export class AgentSession {
             result: undefined,
             aborted,
             willRetry: false,
-            errorMessage: aborted ? undefined : options.errorMessage,
+            requestId: operation.operationId,
+            errorMessage: aborted ? undefined : (options.errorMessage ?? "Compaction did not apply"),
         });
         this._releaseCompactionController(options.signal);
     }
@@ -3136,7 +3252,7 @@ export class AgentSession {
         if (!this._ownsCompactionController(controller, request.owner)) {
             throw new CompactionExecutionError(new CompactionCancelledError(), false, true);
         }
-        const requestId = randomUUID();
+        const requestId = request.requestId ?? randomUUID();
         const operationId = this._compactionLifecycle.begin({
             operationId: requestId,
             stage: "execution",
@@ -3391,6 +3507,10 @@ export class AgentSession {
      * Cancel in-progress compaction (manual or auto).
      */
     abortCompaction() {
+        const lifecycleState = this._compactionLifecycle.state;
+        const activeFeedbackRequestId = lifecycleState.status === "running" && lifecycleState.stage === "feedback"
+            ? lifecycleState.operationId
+            : undefined;
         const feedbackOperation = this._compactionLifecycle.abort(this._messageRevision);
         this._compactionAbortController?.abort();
         this._autoCompactionAbortController?.abort();
@@ -3402,6 +3522,7 @@ export class AgentSession {
                 result: undefined,
                 aborted: true,
                 willRetry: false,
+                requestId: activeFeedbackRequestId,
             });
         }
     }
@@ -3607,16 +3728,20 @@ export class AgentSession {
             else {
                 const messages = filterContextExcludedMessages(this.agent.state.messages);
                 const estimate = estimateContextTokens(messages);
-                if (estimate.lastUsageIndex === null)
-                    return false; // No usage data at all
-                // Verify the usage source is post-compaction. Kept pre-compaction messages
-                // have stale usage reflecting the old (larger) context and would falsely
-                // trigger compaction right after one just finished.
-                const usageMsg = messages[estimate.lastUsageIndex];
-                if (compactionEntry &&
-                    usageMsg.role === "assistant" &&
-                    this._isAssistantFromBeforeLatestCompaction(usageMsg)) {
-                    return false;
+                if (estimate.lastUsageIndex === null) {
+                    if (!this._isRequiredCompactionError(assistantMessage))
+                        return false;
+                }
+                else {
+                    // Verify the usage source is post-compaction. Kept pre-compaction messages
+                    // have stale usage reflecting the old (larger) context and would falsely
+                    // trigger compaction right after one just finished.
+                    const usageMsg = messages[estimate.lastUsageIndex];
+                    if (compactionEntry &&
+                        usageMsg.role === "assistant" &&
+                        this._isAssistantFromBeforeLatestCompaction(usageMsg)) {
+                        return false;
+                    }
                 }
                 contextTokens = estimate.tokens;
             }
@@ -3626,7 +3751,7 @@ export class AgentSession {
                 return await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction);
             }
             else {
-                const compacted = await this._runAutoCompaction("threshold", false);
+                const compacted = await this._runAutoCompaction("threshold", retryAfterCompaction);
                 if (!compacted &&
                     this._compactionLifecycle.state.status === "failed" &&
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
@@ -3646,13 +3771,15 @@ export class AgentSession {
     }
     async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false, allowSummaryOnly = false) {
         const controller = new AbortController();
+        const requestId = randomUUID();
         this._claimCompactionController(controller, "compaction");
-        this._emit({ type: "compaction_start", reason });
+        this._emit({ type: "compaction_start", reason, requestId });
         try {
             const execution = await this._executeCompaction({
                 controller,
                 owner: "compaction",
                 reason,
+                requestId,
                 willRetry,
                 lastAssistantMessage,
                 skipAbortedCheck,
@@ -3680,6 +3807,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted ? undefined : `Pre-prompt compaction failed: ${errorMessage}`,
             });
             return false;
@@ -3792,9 +3920,10 @@ export class AgentSession {
         const finishCompactionWork = this._sessionWorkBarrier.begin();
         const agentMessagesAtStart = this.agent.state.messages.slice();
         const autoCompactionController = new AbortController();
+        const requestId = randomUUID();
         this._claimCompactionController(autoCompactionController, "auto");
         const endBeforeExecution = () => {
-            this._emit({ type: "compaction_start", reason });
+            this._emit({ type: "compaction_start", reason, requestId });
             if (reason === "overflow" && this._autoCompactionAbortController === autoCompactionController) {
                 this._overflowRecoveryAttempted = false;
             }
@@ -3811,6 +3940,7 @@ export class AgentSession {
                 result: undefined,
                 aborted: autoCompactionController.signal.aborted,
                 willRetry: false,
+                requestId,
             });
             return false;
         };
@@ -3838,11 +3968,12 @@ export class AgentSession {
             }
             if (!this._ownsCompactionController(autoCompactionController, "auto"))
                 return false;
-            this._emit({ type: "compaction_start", reason });
+            this._emit({ type: "compaction_start", reason, requestId });
             const execution = await this._executeCompaction({
                 controller: autoCompactionController,
                 owner: "auto",
                 reason,
+                requestId,
                 willRetry,
                 agentMessagesAtStart,
             });
@@ -3888,6 +4019,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted
                     ? undefined
                     : reason === "overflow"
@@ -4169,6 +4301,7 @@ export class AgentSession {
             compact: (options) => {
                 const admission = this._claimPendingCompactionAdmission();
                 const controller = admission.controller;
+                const requestId = randomUUID();
                 void (async () => {
                     let outcome = "failed";
                     let compactionCompleted = false;
@@ -4177,11 +4310,12 @@ export class AgentSession {
                         await this._abortActiveAgentAndRetry("system");
                         this._disconnectFromAgent();
                         disconnected = true;
-                        this._emit({ type: "compaction_start", reason: "extension" });
+                        this._emit({ type: "compaction_start", reason: "extension", requestId });
                         const execution = await this._executeCompaction({
                             controller,
                             owner: "compaction",
                             reason: "extension",
+                            requestId,
                             customInstructions: options?.customInstructions,
                             willRetry: false,
                         });
@@ -4208,6 +4342,7 @@ export class AgentSession {
                             result: undefined,
                             aborted,
                             willRetry: false,
+                            requestId,
                             errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
                         });
                         const err = error instanceof Error ? error : new Error(String(error));