@code-yeongyu/senpi 2026.8.5 → 2026.8.7

package/dist/core/agent-session.js

@@ -24,6 +24,8 @@ import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
+import { AgentAbortProvenance } from "./agent-abort-provenance.js";
+import { AgentSettledDelivery } from "./agent-settled-delivery.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
@@ -46,7 +48,7 @@ import { isBillingErrorMessage } from "./retry-fallback/billing.js";
 import { formatSelector } from "./retry-fallback/chains.js";
 import { RetryFallbackController } from "./retry-fallback/controller.js";
 import { SelectorCooldowns } from "./retry-fallback/cooldown.js";
-import { classifyRateLimitedWait, nextInTurnDelayMs, probeBackSchedule, } from "./retry-fallback/hint-policy.js";
+import { classifyRateLimitedWait, degradeWithoutFallback, nextInTurnDelayMs, probeBackSchedule, } from "./retry-fallback/hint-policy.js";
 import { createFallbackLogger } from "./retry-fallback/log.js";
 import { ProbeBackScheduler } from "./retry-fallback/probe-scheduler.js";
 import { validateFallbackChains } from "./retry-fallback/validate.js";
@@ -109,7 +111,9 @@ function describeCompactionRejection(cause) {
         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":
-            return "Compaction rejected: per-turn compaction cap reached for this turn.";
+            // Historical cause identifier kept for extension-API stability; since the
+            // per-turn soft cap was removed it fires only at the absolute session cap.
+            return "Compaction rejected: absolute compaction cap reached for this session.";
         case "stale-revision":
             return "Compaction rejected: the session changed while the summary was being prepared. Retry compaction against the latest context.";
     }
@@ -245,8 +249,10 @@ export class AgentSession {
         this._retryPromise = undefined;
         this._retryResolve = undefined;
         this._userAbortPromise = undefined;
-        this._agentAbortSource = undefined;
+        this._abortProvenance = new AgentAbortProvenance();
+        this._agentSettledDelivery = new AgentSettledDelivery();
         this._suppressQueuedContinuationAfterUserAbort = false;
+        this._userAbortGeneration = 0;
         /** Set when clearQueue({ abortWillFollow: true }) drains queues immediately before abort(). */
         this._hadClearedQueuedMessages = false;
         this._extensionEventSignal = undefined;
@@ -796,17 +802,27 @@ export class AgentSession {
             await this.agent.waitForIdle();
         }
         if (!this._isAgentRunActive) {
+            this._abortProvenance.closeAgentEndBoundary();
             this._resolveIdleWaitIfIdle();
             return;
         }
         this._isAgentRunActive = false;
+        let deferredActions = [];
+        this._agentSettledDelivery.begin(this._userAbortGeneration);
         try {
             await this._extensionRunner.emit({ type: "agent_settled" });
             this._emit({ type: "agent_settled" });
+            if (this._abortProvenance.takeLateUserJoin())
+                await this._emitSessionAbort();
+            deferredActions = this._agentSettledDelivery.finish(this._userAbortGeneration);
         }
         finally {
+            this._agentSettledDelivery.cancel();
+            this._abortProvenance.closeAgentEndBoundary();
             this._resolveIdleWaitIfIdle();
         }
+        for (const action of deferredActions)
+            action();
     }
     async _promptAgent(messages) {
         this._isAgentRunActive = true;
@@ -1084,8 +1100,14 @@ export class AgentSession {
         finally {
             this._extensionEventSignal = undefined;
         }
+        if (event.type === "agent_end" && this._abortProvenance.takeLateUserJoin())
+            await this._emitSessionAbort();
         // Notify all listeners
         this._emit(event.type === "agent_end" ? { ...event, willRetry: agentEndWillRetry } : event);
+        if (event.type === "agent_end") {
+            if (this._abortProvenance.takeLateUserJoin())
+                await this._emitSessionAbort();
+        }
         // Handle session persistence
         if (event.type === "message_end") {
             // Check if this is a custom message from extensions
@@ -1154,7 +1176,9 @@ export class AgentSession {
             // Retry transient failures normally and eligible hard errors only through a fallback.
             const retryableError = this._isRetryableError(msg);
             const hardErrorFallbackEligible = this._isHardErrorFallbackEligible(msg);
-            const retryCanAdmitProvider = this.settingsManager.getRetrySettings().enabled && (retryableError || hardErrorFallbackEligible);
+            const retryCanAdmitProvider = !userAbortSuppressedQueuedContinuation &&
+                this.settingsManager.getRetrySettings().enabled &&
+                (retryableError || hardErrorFallbackEligible);
             let compactedBeforeRetry = false;
             if (retryCanAdmitProvider &&
                 requiredAutoCompaction &&
@@ -1164,7 +1188,7 @@ export class AgentSession {
                 retryContinuationBlocked = !compactedBeforeRetry;
             }
             let retryOutcome = "not-handled";
-            if (!retryContinuationBlocked) {
+            if (!retryContinuationBlocked && !userAbortSuppressedQueuedContinuation) {
                 if (retryableError) {
                     retryOutcome = await this._handleRetryableError(msg);
                 }
@@ -1172,11 +1196,13 @@ export class AgentSession {
                     retryOutcome = await this._handleRetryableError(msg, { hardErrorFallback: true });
                 }
             }
-            if (retryOutcome === "continued")
+            if (retryOutcome === "continued") {
+                this._abortProvenance.closeAgentEndBoundary();
                 return;
+            }
             this._resolveRetry();
             retryContinuationBlocked ||= retryOutcome === "blocked";
-            if (!retryContinuationBlocked) {
+            if (!retryContinuationBlocked && !userAbortSuppressedQueuedContinuation) {
                 if (compactedBeforeRetry && this.agent.hasQueuedMessages()) {
                     // Accepted recovery supersedes the stored admission rejection: the
                     // queued continuation is about to run, so the originating prompt must
@@ -1223,6 +1249,9 @@ export class AgentSession {
             if (!launchedContinuation) {
                 await this._emitAgentSettled();
             }
+            else {
+                this._abortProvenance.closeAgentEndBoundary();
+            }
         }
     }
     /** Resolve the pending retry promise */
@@ -1238,6 +1267,10 @@ export class AgentSession {
         this._hintDeadlineMs = undefined;
         this._cumulativeHintedWaitMs = 0;
     }
+    async _emitSessionAbort() {
+        await this._extensionRunner.emit({ type: "session_abort" });
+        this._emit({ type: "session_abort" });
+    }
     /**
      * Arm the probe-back scheduler for a tier-2 demoted selector. The scheduler
      * will fire at most two probes (half-hint, then deadline) and clear the
@@ -1377,19 +1410,12 @@ export class AgentSession {
             await this._extensionRunner.emit({ type: "agent_start" });
         }
         else if (event.type === "agent_end") {
-            const abortSource = this._agentAbortSource;
-            const aborted = abortSource !== undefined || this._findLastAssistantInMessages(event.messages)?.stopReason === "aborted";
+            const extensionEvent = this._abortProvenance.beginAgentEnd(event.messages, agentEndWillRetry, this._findLastAssistantInMessages(event.messages)?.stopReason === "aborted");
             try {
-                await this._extensionRunner.emit({
-                    type: "agent_end",
-                    messages: event.messages,
-                    willRetry: agentEndWillRetry,
-                    ...(aborted ? { aborted: true } : {}),
-                    ...(abortSource === undefined ? {} : { abortSource }),
-                });
+                await this._extensionRunner.emit(extensionEvent);
             }
             finally {
-                this._agentAbortSource = undefined;
+                this._abortProvenance.endAgentEnd(extensionEvent);
             }
         }
         else if (event.type === "turn_start") {
@@ -2406,6 +2432,7 @@ export class AgentSession {
      * @param options.deliverAs Delivery mode: "steer", "followUp", or "nextTurn"
      */
     async sendCustomMessage(message, options) {
+        const userAbortGeneration = this._userAbortGeneration;
         const appMessage = {
             role: "custom",
             customType: message.customType,
@@ -2425,6 +2452,8 @@ export class AgentSession {
         try {
             if (waitForExistingSessionWork) {
                 await this._waitForSettledSessionWork();
+                if (userAbortGeneration !== this._userAbortGeneration)
+                    return;
                 finishSessionWork = this._sessionWorkBarrier.begin();
             }
             if (options?.deliverAs === "nextTurn") {
@@ -2625,31 +2654,20 @@ export class AgentSession {
      * Abort current operation and wait for agent to become idle.
      */
     async abort() {
-        // Capture gap-state BEFORE _abortActiveAgentAndRetry resets retry/compaction state.
-        // A mid-run abort (actively streaming with no pending retry) is delivered via
-        // agent_end (abortSource "user") — no session_abort needed. The gap case is when
-        // no agent_end will fire to carry the abort signal:
-        //   - retry backoff (_retryAbortController defined — the error agent_end already
-        //     fired, agent.abort() during backoff is a no-op, no new agent_end)
-        //   - compaction (!isStreaming && isCompacting)
-        //   - queued continuation that was already cleared by the caller (TUI clears queues
-        //     before calling abort, so pendingMessageCount is 0 but _hadClearedQueuedMessages
-        //     records that messages were present)
-        // Purely-idle defensive aborts (e.g. RPC session close on an idle session) must not
-        // fire session_abort.
+        // Streaming aborts are carried by agent_end provenance; only gaps need session_abort.
         const wasMidRun = this.isStreaming && this._retryAbortController === undefined;
         const hadRetryBackoff = this._retryAbortController !== undefined;
         const hadCompactionOrPending = !this.isStreaming && (this.isCompacting || this.pendingMessageCount > 0);
         const hadClearedQueues = this._hadClearedQueuedMessages;
+        const joinedAgentEndBoundary = this._abortProvenance.hasOpenAgentEndBoundary;
         this._hadClearedQueuedMessages = false;
-        const shouldEmitAbort = !wasMidRun && (hadRetryBackoff || hadCompactionOrPending || hadClearedQueues);
+        const shouldEmitAbort = !joinedAgentEndBoundary && !wasMidRun && (hadRetryBackoff || hadCompactionOrPending || hadClearedQueues);
         this.abortCompaction();
         await this._abortActiveAgentAndRetry("user");
         if (!shouldEmitAbort)
             return;
         try {
-            await this._extensionRunner.emit({ type: "session_abort" });
-            this._emit({ type: "session_abort" });
+            await this._emitSessionAbort();
         }
         catch {
             // Extension runner may be torn down during RPC close — best-effort.
@@ -3038,18 +3056,32 @@ export class AgentSession {
         this._pendingCompactionAdmission = undefined;
         admission.finishSessionWork();
     }
+    _recordUserAbort() {
+        this._suppressQueuedContinuationAfterUserAbort = true;
+        this._userAbortGeneration += 1;
+    }
     async _abortActiveAgentAndRetry(source) {
         this.abortRetry();
         this.abortBranchSummary();
+        if (this._userAbortPromise === undefined) {
+            const boundaryJoin = this._abortProvenance.joinOpenBoundary(source);
+            if (boundaryJoin !== undefined) {
+                if (boundaryJoin.userOwned)
+                    this._recordUserAbort();
+                return;
+            }
+        }
         if (this._userAbortPromise) {
-            this.agent.abort();
+            const joined = this._abortProvenance.join(source, this.isStreaming);
+            if (joined.userOwned)
+                this._recordUserAbort();
+            if (joined.abortCurrentAgent)
+                this.agent.abort();
             await this._userAbortPromise;
             return;
         }
-        if (this.isStreaming) {
-            this._suppressQueuedContinuationAfterUserAbort = true;
-            this._agentAbortSource = source;
-        }
+        if (this.isStreaming && this._abortProvenance.begin(source))
+            this._recordUserAbort();
         const abortPromise = (async () => {
             this.agent.abort();
             await this.waitForIdle();
@@ -4178,13 +4210,16 @@ export class AgentSession {
         };
         runner.bindCore({
             sendMessage: (message, options) => {
-                this.sendCustomMessage(message, options).catch((err) => {
+                const send = () => this.sendCustomMessage(message, options).catch((err) => {
                     runner.emitError({
                         extensionPath: RUNTIME_EXTENSION_PATH,
                         event: "send_message",
                         error: err instanceof Error ? err.message : String(err),
                     });
                 });
+                if (this._agentSettledDelivery.defer(send))
+                    return;
+                send();
             },
             sendUserMessage: (content, options) => {
                 this.sendUserMessage(content, options).catch((err) => {
@@ -4247,11 +4282,11 @@ export class AgentSession {
             getAgentDir: () => this._agentDir,
             isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
             getSignal: () => this._extensionEventSignal ?? this.agent.signal,
-            abort: () => {
-                if (this._extensionAbortHandler) {
-                    this._extensionAbortHandler();
-                    return;
-                }
+            abort: (source = "user") => {
+                if (source === "system")
+                    return void this._abortActiveAgentAndRetry("system");
+                if (this._extensionAbortHandler)
+                    return this._extensionAbortHandler();
                 void this.abort();
             },
             hasPendingMessages: () => this.pendingMessageCount > 0,
@@ -4663,6 +4698,41 @@ export class AgentSession {
             },
         };
     }
+    /**
+     * A 429-class failure with no usable fallback candidate must not fail the
+     * turn with zero attempts: a provider answering 429 is asking for a retry.
+     * No-hint and tier2 waits degrade to same-model in-turn retries under the
+     * normal retry budget (tier2 clamps the hinted wait to the in-turn cap);
+     * only tier3 hour-plus waits stay terminal, with the requested wait named
+     * in the final error. Returns the in-turn retry delay, or undefined after
+     * emitting the terminal auto_retry_end.
+     */
+    _degradeRateLimitedWithoutFallback(tier, hintMs, message, errorMessage) {
+        const settings = this.settingsManager.getRetrySettings();
+        const hintSettings = this.settingsManager.getHintPolicySettings();
+        const finishTurn = (attempt, finalError) => {
+            const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+            if (exhaustedChainKey) {
+                this._emit({ type: "retry_fallback_exhausted", chainKey: exhaustedChainKey, lastError: errorMessage });
+            }
+            this._emit({ type: "auto_retry_end", success: false, attempt, finalError });
+            this._retryAttempt = 0;
+            this._resetHintTierState();
+            this._resolveRetry();
+        };
+        const degraded = degradeWithoutFallback(tier, hintMs, this._retryAttempt + 1, settings.baseDelayMs, hintSettings.hintedWaitCapMs);
+        if (degraded.kind === "fail") {
+            const waitSeconds = Math.ceil(degraded.hintMs / 1000);
+            finishTurn(this._retryAttempt, `Provider requested a ${waitSeconds}s wait before retrying and no usable fallback model is available. ${message.errorMessage ?? ""}`);
+            return undefined;
+        }
+        this._retryAttempt++;
+        if (this._retryAttempt > settings.maxRetries) {
+            finishTurn(this._retryAttempt - 1, message.errorMessage);
+            return undefined;
+        }
+        return degraded.delayMs;
+    }
     /**
      * Handle retryable errors with exponential backoff.
      * @returns whether retry continuation started, was blocked by compaction, or was not handled
@@ -4760,30 +4830,17 @@ export class AgentSession {
                 const tier = classifyRateLimitedWait(hintMs, hintSettings);
                 is429TierRouted = true;
                 if (tier === "no-hint-fast-fallback") {
-                    // Skip same-model retries entirely; fall back immediately.
+                    // Fall back immediately when a candidate exists; otherwise degrade
+                    // to same-model in-turn retries instead of failing the turn.
                     switchedFallback = await this._retryFallback.tryFallback("transient", { errorMessage });
                     if (switchedFallback) {
                         this._retryAttempt = 1;
                     }
                     else {
-                        const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
-                        if (exhaustedChainKey) {
-                            this._emit({
-                                type: "retry_fallback_exhausted",
-                                chainKey: exhaustedChainKey,
-                                lastError: errorMessage,
-                            });
-                        }
-                        this._emit({
-                            type: "auto_retry_end",
-                            success: false,
-                            attempt: 0,
-                            finalError: message.errorMessage,
-                        });
-                        this._retryAttempt = 0;
-                        this._resetHintTierState();
-                        this._resolveRetry();
-                        return "not-handled";
+                        const degradedDelayMs = this._degradeRateLimitedWithoutFallback(tier, hintMs, message, errorMessage);
+                        if (degradedDelayMs === undefined)
+                            return "not-handled";
+                        hintTierDelayMs = degradedDelayMs;
                     }
                 }
                 else if (tier === "tier1-in-turn") {
@@ -4879,24 +4936,10 @@ export class AgentSession {
                         }
                     }
                     else {
-                        const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
-                        if (exhaustedChainKey) {
-                            this._emit({
-                                type: "retry_fallback_exhausted",
-                                chainKey: exhaustedChainKey,
-                                lastError: errorMessage,
-                            });
-                        }
-                        this._emit({
-                            type: "auto_retry_end",
-                            success: false,
-                            attempt: 0,
-                            finalError: message.errorMessage,
-                        });
-                        this._retryAttempt = 0;
-                        this._resetHintTierState();
-                        this._resolveRetry();
-                        return "not-handled";
+                        const degradedDelayMs = this._degradeRateLimitedWithoutFallback(tier, hintMs, message, errorMessage);
+                        if (degradedDelayMs === undefined)
+                            return "not-handled";
+                        hintTierDelayMs = degradedDelayMs;
                     }
                 }
             }