@code-yeongyu/senpi 2026.10.5 → 2026.10.7

package/dist/core/extensions/eval-handle-host.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Host capability that lets an eval cell wait on, inspect and control work the host owns (agent runs,
+ * workpools). The task owner implements it and registers it; codemode only consumes it. Every operation is
+ * fenced by the owning session, the handle id and its run epoch: a ref whose epoch is no longer live is
+ * refused with `eval_handle_stale`, never silently redirected to a successor run.
+ */
+export type HandleKind = "agent" | "completion" | "workpool";
+export interface HandleRef {
+    readonly kind: HandleKind;
+    readonly id: string;
+    readonly run_epoch: number;
+}
+export type HandlePhase = "pending" | "succeeded" | "failed" | "cancelled" | "lost";
+export interface HandleSnapshot {
+    readonly ref: HandleRef;
+    readonly phase: HandlePhase;
+    readonly host_status: string;
+    /** Strictly increases with every change of this ref; a consumer drops an update whose revision is not newer. */
+    readonly revision: number;
+}
+export interface HandleError {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: unknown;
+}
+export type HandleOutcome = {
+    readonly status: "fulfilled";
+    readonly ref: HandleRef;
+    readonly value: unknown;
+} | {
+    readonly status: "rejected";
+    readonly ref: HandleRef;
+    readonly error: HandleError;
+};
+export interface HandleCallContext {
+    readonly ownerSessionId: string;
+    readonly signal?: AbortSignal;
+}
+export interface HandleWatch {
+    /** One snapshot per watched ref, taken atomically with the subscription. */
+    readonly initial: readonly HandleSnapshot[];
+    /** Every change after `initial`, in order; a change during `watch()` setup arrives here exactly once. */
+    readonly updates: AsyncIterable<HandleSnapshot>;
+    close(): void;
+}
+export interface CancelReceipt {
+    readonly ref: HandleRef;
+    /** False when the run had already ended; cancelling twice is not an error. */
+    readonly cancelled: boolean;
+    readonly phase: HandlePhase;
+}
+export interface OutputRequest {
+    readonly format?: "raw" | "tail";
+    readonly offset?: number;
+    readonly limit?: number;
+}
+export interface OutputSnapshot {
+    readonly ref: HandleRef;
+    readonly text: string;
+    readonly offset: number;
+    readonly total: number;
+    readonly truncated: boolean;
+}
+export interface EvalHandleHost {
+    readonly version: 1;
+    watch(refs: readonly HandleRef[], ctx: HandleCallContext): Promise<HandleWatch>;
+    /** The terminal outcome; rejects with `eval_handle_pending` while the run is still pending. */
+    result(ref: HandleRef, ctx: HandleCallContext): Promise<HandleOutcome>;
+    /** Agent refs only; others refuse with `eval_handle_operation_unsupported`. */
+    send(ref: HandleRef, message: string, ctx: HandleCallContext): Promise<HandleSnapshot>;
+    cancel(ref: HandleRef, ctx: HandleCallContext): Promise<CancelReceipt>;
+    output(ref: HandleRef, request: OutputRequest, ctx: HandleCallContext): Promise<OutputSnapshot>;
+}
+export declare const EVAL_HANDLE_ERROR_CODES: readonly ["eval_handle_stale", "eval_handle_forbidden", "eval_handle_not_found", "eval_handle_pending", "eval_handle_operation_unsupported", "eval_wait_unavailable", "eval_wait_timeout", "eval_wait_empty", "eval_pool_open", "eval_workpool_failed"];
+export type EvalHandleErrorCode = (typeof EVAL_HANDLE_ERROR_CODES)[number];
+export declare class EvalHandleError extends Error {
+    readonly name = "EvalHandleError";
+    readonly code: EvalHandleErrorCode;
+    readonly details?: unknown;
+    constructor(code: EvalHandleErrorCode, message: string, details?: unknown);
+}
+//# sourceMappingURL=eval-handle-host.d.ts.map

package/dist/core/extensions/eval-handle-host.js

@@ -0,0 +1,28 @@
+/**
+ * Host capability that lets an eval cell wait on, inspect and control work the host owns (agent runs,
+ * workpools). The task owner implements it and registers it; codemode only consumes it. Every operation is
+ * fenced by the owning session, the handle id and its run epoch: a ref whose epoch is no longer live is
+ * refused with `eval_handle_stale`, never silently redirected to a successor run.
+ */
+export const EVAL_HANDLE_ERROR_CODES = [
+    "eval_handle_stale",
+    "eval_handle_forbidden",
+    "eval_handle_not_found",
+    "eval_handle_pending",
+    "eval_handle_operation_unsupported",
+    "eval_wait_unavailable",
+    "eval_wait_timeout",
+    "eval_wait_empty",
+    "eval_pool_open",
+    "eval_workpool_failed",
+];
+export class EvalHandleError extends Error {
+    constructor(code, message, details) {
+        super(`${code}: ${message}`);
+        this.name = "EvalHandleError";
+        this.code = code;
+        if (details !== undefined)
+            this.details = details;
+    }
+}
+//# sourceMappingURL=eval-handle-host.js.map

package/dist/core/extensions/loader.js

@@ -209,6 +209,7 @@ export function createExtensionRuntime() {
             for (const unsubscribe of eventBusUnsubscribers)
                 unsubscribe();
             eventBusUnsubscribers.clear();
+            runtime.evalHandleHost = undefined;
             runtimeFactories.delete(runtime);
         },
         trackEventBusSubscription: (unsubscribe) => {
@@ -350,6 +351,10 @@ function createExtensionAPI(extension, runtime, cwd, eventBus, session) {
             extension.lazyToolActivators = activators;
             runtime.registerLazyToolActivator(activator);
         },
+        provideEvalHandleHost(host) {
+            runtime.assertActive();
+            runtime.evalHandleHost = host;
+        },
         registerRemovedToolHint(name, hint) {
             runtime.assertActive();
             let hints = extension.removedToolHints;

package/dist/core/extensions/runner.js

@@ -955,6 +955,10 @@ export class ExtensionRunner {
                 runner.assertActive();
                 return kernelToolsStorage.getStore();
             },
+            get evalHandleHost() {
+                runner.assertActive();
+                return runner.runtime.evalHandleHost;
+            },
             abort: (source) => {
                 runner.assertActive();
                 runner.abortFn(source);

package/dist/core/extensions/types.d.ts

@@ -34,6 +34,7 @@ import type { BashToolDetails, BashToolInput, EditToolInput, FindToolDetails, Fi
 import type { ReadClassifier } from "../tools/read-classifiers.ts";
 import type { ModelRoute, ModelRouteRequest, VirtualModelDefinition } from "../virtual-models.ts";
 import type { McpServerDeclaration } from "./builtin/mcp/config-schema.ts";
+import type { EvalHandleHost } from "./eval-handle-host.ts";
 import type { ExtensionKernelTools } from "./kernel-tools-context.ts";
 import type { SessionControlActions, SessionControlWakeEvent } from "./session-control-types.ts";
 export type { ExecOptions, ExecResult } from "../exec.ts";
@@ -391,6 +392,12 @@ export interface ExtensionContext {
      * JavaScript eval owns the host-tool context; absent on older runtimes.
      */
     readonly kernelTools?: ExtensionKernelTools;
+    /**
+     * Session-scoped host capability behind the in-cell `wait()` / `handle()` helpers: watch, send to,
+     * cancel and read host-owned work (agent runs, workpools) fenced by owner, id and run epoch.
+     * Provided by the task owner through `pi.provideEvalHandleHost`; absent on runtimes without a provider.
+     */
+    readonly evalHandleHost?: EvalHandleHost;
     /** Abort the current agent operation */
     abort(source?: "user" | "system"): void;
     /** Whether there are queued messages waiting */
@@ -1797,6 +1804,12 @@ export interface ExtensionAPI {
     registerTool<TParams extends TSchema = TSchema, TDetails = unknown, TState = any>(tool: ToolDefinition<TParams, TDetails, TState>): void;
     /** Register migration guidance returned when an intentionally removed tool is called. */
     registerRemovedToolHint(name: string, hint: string): void;
+    /**
+     * Provide this session's `EvalHandleHost` (the task/workpool owner implements it). Session-scoped:
+     * every extension loaded in the same session reads it back as `ctx.evalHandleHost`; the last
+     * provider wins, and a replaced or reloaded session starts without one.
+     */
+    provideEvalHandleHost(host: EvalHandleHost): void;
     /**
      * Register a callback that may activate a registered-but-inactive tool on demand.
      * Called only when executeTool would otherwise fail with `inactive_tool`. Return
@@ -2302,6 +2315,8 @@ export interface ExtensionRuntimeState {
     registerRemovedToolHint: RegisterRemovedToolHintHandler;
     registerVirtualModel: (definition: VirtualModelDefinition, extensionPath?: string) => void;
     unregisterVirtualModel: (provider: string, id: string) => void;
+    /** The session's eval handle host, set by `pi.provideEvalHandleHost`; cleared when the runtime is invalidated. */
+    evalHandleHost?: EvalHandleHost;
 }
 /**
  * Action implementations for pi.* API methods.

package/dist/core/retry-fallback/usage-limit.js

@@ -4,6 +4,9 @@ import { isBillingErrorMessage } from "./billing.js";
 // Subscription limit prose that carries no quota/billing keyword, e.g. Claude's
 // "You've hit your session limit · resets 3pm" and the SDK terminal reasons.
 const SUBSCRIPTION_LIMIT_PATTERN = /\bhit\s+your\b[^.]*\blimit\b|\b(?:session|weekly|monthly|daily|hourly|\d+[- ]hour|usage)\s+limit\b|\bblocking_limit\b|\brapid_refill_breaker\b/i;
+// A plan cap that tells the user to switch models, e.g. Devin's "Reached free model rate limit. ...
+// switch to a different model" (senpi#2660). An ordinary "rate limit exceeded" stays transient.
+const PLAN_MODEL_LIMIT_PATTERN = /\breached\b[^.]*\b(?:free|plan|tier|model)\b[^.]*\blimit\b[\s\S]*\bswitch to (?:a |an )?(?:different|another) model\b/i;
 const MODEL_SCOPE_PATTERN = /\bmodels?\b|\bpremium\b|\b(?:opus|sonnet|haiku|fable|mythos)\b/i;
 export function usageLimitScope(errorMessage) {
     if (errorMessage === undefined)
@@ -14,7 +17,8 @@ export function usageLimitScope(errorMessage) {
         return "model";
     const limited = isQuotaExhaustionMessage(errorMessage) ||
         isBillingErrorMessage(errorMessage) ||
-        SUBSCRIPTION_LIMIT_PATTERN.test(errorMessage);
+        SUBSCRIPTION_LIMIT_PATTERN.test(errorMessage) ||
+        PLAN_MODEL_LIMIT_PATTERN.test(errorMessage);
     if (!limited)
         return undefined;
     return MODEL_SCOPE_PATTERN.test(errorMessage) ? "model" : "account";

package/dist/core/tools/diff-render.d.ts

@@ -9,5 +9,9 @@ export type RenderToolDiffOptions = {
     filePath?: string;
     theme: ToolDiffTheme;
 };
+export declare function countDiffChanges(diffText: string): {
+    added: number;
+    removed: number;
+};
 export declare function renderToolDiff(diffText: string, options: RenderToolDiffOptions): string;
 //# sourceMappingURL=diff-render.d.ts.map

package/dist/core/tools/diff-render.js

@@ -79,6 +79,19 @@ function renderToolDiffLine(line, filePath, theme, contentOverride) {
     const rendered = `${theme.fg(diffColor, line.sign)}${lineNumber} ${content}`;
     return theme.bg(background, rendered);
 }
+export function countDiffChanges(diffText) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diffText.split("\n")) {
+        if (line.startsWith("+++") || line.startsWith("---"))
+            continue;
+        if (line.startsWith("+"))
+            added++;
+        else if (line.startsWith("-"))
+            removed++;
+    }
+    return { added, removed };
+}
 export function renderToolDiff(diffText, options) {
     const parsedLines = diffText.split("\n").map(parseRenderableDiffLine);
     const rendered = [];

package/dist/core/tools/renderers/edit.js

@@ -6,7 +6,7 @@
  * definition, so the tool's public shape is unchanged.
  */
 import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
-import { renderToolDiff } from "../diff-render.js";
+import { countDiffChanges, renderToolDiff } from "../diff-render.js";
 import { computeEditsDiff } from "../edit-diff.js";
 import { renderToolPath, str } from "../render-utils.js";
 function createEditCallRenderComponent() {
@@ -48,9 +48,11 @@ function getRenderablePreviewInput(args) {
     }
     return null;
 }
-function formatEditCall(args, theme, cwd) {
+function formatEditCall(args, theme, cwd, diffText) {
     const pathDisplay = renderToolPath(str(args?.file_path ?? args?.path), theme, cwd);
-    return `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`;
+    const counts = diffText === undefined ? undefined : countDiffChanges(diffText);
+    const countTag = counts === undefined ? "" : theme.fg("muted", ` (+${counts.added}/-${counts.removed})`);
+    return `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}${countTag}`;
 }
 function formatEditResult(args, preview, result, theme, isError) {
     const rawPath = str(args?.file_path ?? args?.path);
@@ -87,7 +89,7 @@ function getEditHeaderBg(preview, settledError, theme) {
 function buildEditCallComponent(component, args, theme, cwd) {
     component.setBgFn(getEditHeaderBg(component.preview, component.settledError, theme));
     component.detachAll();
-    component.addChild(new Text(formatEditCall(args, theme, cwd), 0, 0));
+    component.addChild(new Text(formatEditCall(args, theme, cwd, component.preview && !("error" in component.preview) ? component.preview.diff : undefined), 0, 0));
     if (!component.preview) {
         return component;
     }

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { type OAuthCredential, readStoredCredential } from "./core/auth-storage.
 export { type BranchPreparation, type BranchSummaryResult, type CacheFriendlySummaryOptions, type CollectEntriesResult, type CompactionResult, type CutPointResult, calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, type FileOperations, findCutPoint, findTurnStartIndex, type GenerateBranchSummaryOptions, generateBranchSummary, generateSummary, generateSummaryWithUsage, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact, } from "./core/compaction/index.ts";
 export { compareEngineOrdinal, type EngineBuildIdentity, type EngineBuildInput, type EngineOrdinal, type EngineOrdinalScheme, engineBuildIdentity, engineBuildIdentityFrom, } from "./core/engine-build-identity.ts";
 export { createEventBus, type EventBus, type EventBusController } from "./core/event-bus.ts";
+export { type CancelReceipt, EVAL_HANDLE_ERROR_CODES, EvalHandleError, type EvalHandleErrorCode, type EvalHandleHost, type HandleCallContext, type HandleError, type HandleKind, type HandleOutcome, type HandlePhase, type HandleRef, type HandleSnapshot, type HandleWatch, type OutputRequest, type OutputSnapshot, } from "./core/extensions/eval-handle-host.ts";
 export type { AfterProviderResponseEvent, AgentActivityOutcome, AgentBeforeSettleEvent, AgentBeforeSettleEventResult, AgentEndEvent, AgentSettledEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppKeybinding, AutocompleteProviderFactory, BashToolCallEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, BoundaryContextPreview, BoundaryResult, BoundaryState, BuildSystemPromptOptions, CompactionEntryDraft, CompactOptions, ContextEditEntryDraft, ContextEvent, ContextEventResult, ContextUsage, ContextWithSystemEvent, CustomEntryDraft, CustomMessageEntryDraft, CustomToolCallEvent, EditToolCallEvent, EntryRenderer, EntryRendererOptions, EntryRenderOptions, ExecOptions, ExecResult, ExecuteToolOptions, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionRpcRequestHandler, ExtensionRuntime, ExtensionShortcut, ExtensionToolContext, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionVirtualModel, ExtensionWidgetOptions, FilesystemOperation, FilesystemPolicy, FilesystemPolicyChecker, FilesystemPolicyDecision, FilesystemPolicyRequest, FindToolCallEvent, GrepToolCallEvent, InlineExtension, InputDispositionEvent, InputEvent, InputEventResult, InputSource, KernelPreludeContribution, KeybindingsManager, LoadExtensionsResult, LsToolCallEvent, MarkdownTransformContext, MarkdownTransformer, McpServerDeclaration, MessageEndEvent, MessageEndEventResult, MessageRenderer, MessageRenderOptions, MessageStartEvent, MessageUpdateEvent, ModelSelectEvent, ModelSelectSource, NormalizedBuildSystemPromptOptions, PowerShellToolCallEvent, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventDecision, ProjectTrustEventResult, ProjectTrustHandler, ProviderConfig, ProviderModelConfig, ProviderStreamEvent, ReadToolCallEvent, RegisteredCommand, RegisteredTool, ResolvedCommand, ResourcesDiscoverEvent, ResourcesDiscoverResult, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeForkEvent, SessionBeforeForkResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionBoundaryDraft, SessionCompactEvent, SessionCompactFailedEvent, SessionInfoChangedEvent, SessionParkedEvent, SessionResumedEvent, SessionShutdownEvent, SessionStartEvent, SessionTreeEvent, SlashCommandInfo, SlashCommandSource, SourceInfo, TerminalInputHandler, ThinkingLevelSelectEvent, ToolAnnotations, ToolCallEvent, ToolCallEventResult, ToolDefinition, ToolExecutionEndEvent, ToolExecutionMode, ToolExecutionStartEvent, ToolExecutionUpdateEvent, ToolExposure, ToolInfo, ToolLoadout, ToolLoadoutChanges, ToolNamespace, ToolPermissionRequest, ToolRenderResultOptions, ToolResultEvent, ToolResultEventResult, TurnEndEvent, TurnEndEventResult, TurnStartEvent, UIPromptEndEvent, UIPromptKind, UIPromptStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WorkingIndicatorOptions, WriteToolCallEvent, } from "./core/extensions/index.ts";
 export { createExtensionRuntime, defineTool, discoverAndLoadExtensions, ExtensionRunner, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isPowerShellToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, wrapRegisteredTool, wrapRegisteredTools, } from "./core/extensions/index.ts";
 export { type ExtensionKernelTools, type KernelToolInvokeOptions, type KernelToolInvokeScope, kernelToolsStorage, } from "./core/extensions/kernel-tools-context.ts";

package/dist/index.js

@@ -12,6 +12,7 @@ export { calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAUL
 // Engine build identity: the ordinal clients compare instead of version strings
 export { compareEngineOrdinal, engineBuildIdentity, engineBuildIdentityFrom, } from "./core/engine-build-identity.js";
 export { createEventBus } from "./core/event-bus.js";
+export { EVAL_HANDLE_ERROR_CODES, EvalHandleError, } from "./core/extensions/eval-handle-host.js";
 export { createExtensionRuntime, defineTool, discoverAndLoadExtensions, ExtensionRunner, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isPowerShellToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, wrapRegisteredTool, wrapRegisteredTools, } from "./core/extensions/index.js";
 export { kernelToolsStorage, } from "./core/extensions/kernel-tools-context.js";
 // Notice primitives

package/dist/main.js

@@ -677,6 +677,18 @@ export function createCliRuntimeFactory(configuration, local = {}) {
                 parsed.projectTrustOverride ??
                 (!hasTrustRequiringResources || trustStore.get(cwd) === true));
         const runtimeSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
+        // The opener's per-session fallback policy is an in-memory override: never saved, never shared.
+        if (launchProfile?.retryFallback) {
+            runtimeSettingsManager.applyOverrides({
+                retry: {
+                    modelFallback: launchProfile.retryFallback.modelFallback,
+                    fallbackChains: Object.fromEntries(Object.entries(launchProfile.retryFallback.fallbackChains).map(([key, entries]) => [
+                        key,
+                        [...entries],
+                    ])),
+                },
+            });
+        }
         const services = await createAgentSessionServices({
             cwd,
             agentDir,

package/dist/modes/interactive/interactive-mode.d.ts

@@ -108,6 +108,7 @@ export declare class InteractiveMode {
     private readonly sessionShownTipIds;
     private shortcutOverlay;
     private lastEditorText;
+    private startupProviderGuidanceShown;
     private lastInputWasPaste;
     private sessionLogger;
     private readonly continuityNotices;

package/dist/modes/interactive/interactive-mode.js

@@ -13,6 +13,7 @@ import { spawn, spawnSync } from "child_process";
 import { APP_COMMAND, APP_NAME, APP_TITLE, BRAND, CONFIG_DIR_NAME, DISPLAY_VERSION, expandTildePath, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, } from "../../config.js";
 import { parseSkillBlock, } from "../../core/agent-session.js";
 import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
+import { formatNoModelsAvailableMessage } from "../../core/auth-guidance.js";
 import { isApiKeyLoginProvider } from "../../core/auth-providers.js";
 import { envValue } from "../../core/brand.js";
 import { CACHE_TTL_MS, collectCacheMisses, computeCacheWaste, detectCacheMiss, } from "../../core/cache-stats.js";
@@ -113,7 +114,7 @@ import { buildResourceScopeGroups, formatResourceScopeGroups, getDisplaySourceIn
 import { describeLoginFailure } from "./login-outcome.js";
 import { refreshModelCatalogs } from "./model-catalog-refresh.js";
 import { getModelSearchText } from "./model-search.js";
-import { isNetworkProviderError, isNetworkProviderMessage, ProviderErrorPresentation, } from "./provider-error-presentation.js";
+import { isNetworkProviderError, isNetworkProviderMessage, isRetryableProviderError, ProviderErrorPresentation, } from "./provider-error-presentation.js";
 import { replayAssistantTools } from "./replay-assistant-tools.js";
 import { allScopeSessions, chooseResumePath, currentScopeSessions } from "./resume-rebind.js";
 import { isRiskyMainModel, RISKY_MAIN_MODEL_WARNING } from "./risky-main-model-warning.js";
@@ -554,6 +555,7 @@ export class InteractiveMode {
     constructor(runtimeHost, options = {}) {
         this.sessionShownTipIds = new Set();
         this.lastEditorText = "";
+        this.startupProviderGuidanceShown = false;
         this.lastInputWasPaste = false;
         this.continuityNotices = new ContinuityNoticeTracker();
         this.turnWorkingTip = new WorkingTipCache();
@@ -1323,11 +1325,31 @@ export class InteractiveMode {
         if (modelsJsonError) {
             this.showError(`models.json error: ${modelsJsonError}`);
         }
-        for (const warning of this.session.modelRuntime.getWarnings()) {
-            this.showWarning(warning);
+        const modelRuntimeWarnings = this.session.modelRuntime.getWarnings();
+        // Fold repeated warnings only in quiet startup; a hand-built context without getQuietStartup
+        // is treated as not-quiet so full detail shows (the safe default, and what the old path did).
+        const getQuietStartup = this.settingsManager?.getQuietStartup?.bind(this.settingsManager);
+        const quietStartup = getQuietStartup ? getQuietStartup() : false;
+        if (showsStartupDetails(this.options.verbose, quietStartup)) {
+            for (const warning of modelRuntimeWarnings) {
+                this.showWarning(warning);
+            }
+        }
+        else if (modelRuntimeWarnings.length === 1) {
+            this.showWarning(modelRuntimeWarnings[0]);
+        }
+        else if (modelRuntimeWarnings.length > 1) {
+            this.showNoticeBox({
+                title: `${modelRuntimeWarnings.length} model warnings`,
+                tone: "warning",
+                why: modelRuntimeWarnings[0],
+                extra: modelRuntimeWarnings.slice(1).map((text) => ({ text })),
+            });
         }
         if (modelFallbackMessage) {
             this.showWarning(modelFallbackMessage);
+            if (modelFallbackMessage === formatNoModelsAvailableMessage())
+                this.startupProviderGuidanceShown = true;
         }
         for (const warning of this.session.fallbackValidationWarnings) {
             this.showWarning(warning);
@@ -1805,7 +1827,13 @@ export class InteractiveMode {
             if (options?.sort !== false) {
                 labels.sort((a, b) => a.localeCompare(b));
             }
-            return theme.fg("dim", `  ${labels.join(", ")}`);
+            // A short listing fits on one line and shows in full; a long one (dozens of skills) is
+            // what flooded the first screen on a narrow terminal, so it truncates to a few names
+            // with a +N more hint. The full list is one Ctrl+O away.
+            const shown = labels.length <= 8 ? labels : labels.slice(0, 3);
+            const hidden = labels.length - shown.length;
+            const more = hidden > 0 ? theme.fg("muted", ` +${hidden} more (${keyText("app.tools.expand")})`) : "";
+            return theme.fg("dim", `  ${shown.join(", ")}`) + more;
         };
         // System resources are left out of the compact body; a section with nothing else to show stays
         // hidden until the listing is expanded, where the system group lists them. Bodies are built on
@@ -4185,6 +4213,15 @@ export class InteractiveMode {
             case "resume_context_reduced":
                 this.showWarning(event.notice);
                 break;
+            case "provider_required":
+                // The first notice repeats the startup "No models available" warning (same /login guidance), so it
+                // is absorbed by it; the session emits again only after a turn was admitted in between.
+                if (this.startupProviderGuidanceShown) {
+                    this.startupProviderGuidanceShown = false;
+                    break;
+                }
+                this.showWarning(event.notice);
+                break;
             case "settings_source_selected":
                 this.showSettingsSourceSelected(event);
                 break;
@@ -4475,6 +4512,9 @@ export class InteractiveMode {
                     }
                 }
                 else if (event.result) {
+                    // A successful compaction ends the retry episode: no finish is owed, so a later
+                    // never-retried terminal failure must not reopen the banner.
+                    this.providerErrors?.clear();
                     // Compaction event consumers in the fork are session-backed and do not
                     // necessarily expose InteractiveMode's SessionManager convenience getter.
                     // Keep the structural fallback for focused handler consumers while using
@@ -4520,7 +4560,11 @@ export class InteractiveMode {
                 }
                 else if (event.errorMessage) {
                     const errorMessage = sanitizeTerminalLabel(event.errorMessage);
-                    if (isNetworkProviderError(errorMessage)) {
+                    // The quiet provider-retry banner's finish() closes out a retry recorded in the CURRENT
+                    // episode. A terminal compaction failure after an episode that already finished (or one
+                    // that never retried) must always surface as an error, even when its message looks
+                    // transient ("timeout", "truncated generator").
+                    if (isRetryableProviderError(errorMessage) && this.providerErrors?.awaitingRetryFinish === true) {
                         this.getProviderErrors().finish(errorMessage);
                     }
                     else if (event.reason === "manual") {
@@ -4632,7 +4676,7 @@ export class InteractiveMode {
                 this.setExtensionStatus(FALLBACK_STATUS_KEY, undefined);
                 break;
             case "retry_fallback_exhausted":
-                if (isNetworkProviderError(event.lastError)) {
+                if (isRetryableProviderError(event.lastError)) {
                     this.getProviderErrors().finish(event.lastError);
                     this.setExtensionStatus(FALLBACK_STATUS_KEY, undefined);
                     break;
@@ -4654,7 +4698,7 @@ export class InteractiveMode {
                 });
                 break;
             case "auto_retry_start": {
-                if (isNetworkProviderError(event.errorMessage)) {
+                if (isRetryableProviderError(event.errorMessage)) {
                     this.getProviderErrors().retrying(event.errorMessage, this.toolOutputExpanded);
                 }
                 // During retry waits, isStreaming flips false between attempts. The main Esc handler
@@ -4694,7 +4738,7 @@ export class InteractiveMode {
                 if (event.success || event.finalError === "Retry cancelled") {
                     this.providerErrors?.clear();
                 }
-                else if (isNetworkProviderError(event.finalError)) {
+                else if (isRetryableProviderError(event.finalError)) {
                     this.getProviderErrors().finish(event.finalError, event.attempt);
                 }
                 else {
@@ -4704,7 +4748,7 @@ export class InteractiveMode {
                 break;
             }
             case "summarization_retry_scheduled": {
-                if (isNetworkProviderError(event.errorMessage)) {
+                if (isRetryableProviderError(event.errorMessage)) {
                     this.getProviderErrors().retrying(event.errorMessage, this.toolOutputExpanded);
                 }
                 else {
@@ -4725,7 +4769,7 @@ export class InteractiveMode {
                 break;
             }
             case "summarization_retry_finished": {
-                this.providerErrors?.clear();
+                this.providerErrors?.clearTransient();
                 this.clearStatusIndicator("retry");
                 this.ui.requestRender();
                 break;
@@ -4760,7 +4804,7 @@ export class InteractiveMode {
     showRetryStatusIndicatorWithCadence(event) {
         const refreshIntervalMs = largeSessionWorkingStatusInterval(this.sessionManager.getEntryCount(), DEFAULT_RETRY_STATUS_REFRESH_INTERVAL_MS, LARGE_SESSION_RETRY_STATUS_REFRESH_INTERVAL_MS);
         const indicator = refreshIntervalMs === DEFAULT_RETRY_STATUS_REFRESH_INTERVAL_MS ? undefined : { intervalMs: refreshIntervalMs };
-        this.showStatusIndicator(new RetryStatusIndicator(this.ui, event.attempt, event.maxAttempts, event.delayMs, indicator, isNetworkProviderError(event.errorMessage)));
+        this.showStatusIndicator(new RetryStatusIndicator(this.ui, event.attempt, event.maxAttempts, event.delayMs, indicator, isRetryableProviderError(event.errorMessage)));
         this.ui.requestRender();
     }
     /** Extract text content from a user message */

package/dist/modes/interactive/provider-error-presentation.d.ts

@@ -2,6 +2,15 @@ import type { AssistantMessage } from "@earendil-works/pi-ai";
 import { type Container } from "@earendil-works/pi-tui";
 /** Presentation classification only. Retry eligibility remains owned by AgentSession. */
 export declare function isNetworkProviderError(raw: string | undefined, envelopeOnly?: boolean): boolean;
+/**
+ * True when a provider failure should take the quiet presentation path (one banner, a
+ * status-line countdown while retrying, raw JSON only on expand): any transient failure,
+ * which is a network drop, a 429 rate-limit, or a 5xx. Hard quota/auth/billing failures
+ * classify non-retryable here and stay verbose, because they need a credential or plan
+ * change, not a wait. Delegates to the shared classifier so the transcript decision and
+ * the retry engine never disagree about what is transient.
+ */
+export declare function isRetryableProviderError(raw: string | undefined): boolean;
 export declare function isNetworkProviderMessage(message: AssistantMessage): boolean;
 /** Owns one display episode, not session messages or retry/fallback policy. */
 export declare class ProviderErrorPresentation {
@@ -11,7 +20,23 @@ export declare class ProviderErrorPresentation {
     constructor(chat: Container);
     record(raw: string, expanded?: boolean): void;
     retrying(raw: string, expanded: boolean): void;
+    /** A success or cleanup ends the episode: no finish is owed afterward. */
     clear(): void;
+    /**
+     * The retry engine finishing (summarization_retry_finished): clears the transient row but keeps
+     * the episode marker, because the terminal compaction_end that follows still closes the
+     * exhausted episode out via finish().
+     */
+    clearTransient(): void;
+    /** True while a retry episode is active (a retry was recorded and not yet finished/cleared). */
+    get hasActiveRetry(): boolean;
+    /**
+     * True only while a retry has been recorded in the CURRENT episode and not yet closed out by
+     * finish(). A fresh terminal failure after an episode that already finished returns false, so
+     * it surfaces as a plain error instead of reopening the stale banner.
+     */
+    get awaitingRetryFinish(): boolean;
+    private retryAwaitingFinish;
     finish(raw?: string, attempts?: number): void;
     newTurn(): void;
 }

package/dist/modes/interactive/provider-error-presentation.js

@@ -1,3 +1,4 @@
+import { isRetryableErrorMessage } from "@earendil-works/pi-ai";
 import { Text } from "@earendil-works/pi-tui";
 import { z } from "zod";
 import { keyText } from "./components/keybinding-hints.js";
@@ -25,6 +26,21 @@ export function isNetworkProviderError(raw, envelopeOnly = false) {
         throw error;
     }
 }
+/**
+ * True when a provider failure should take the quiet presentation path (one banner, a
+ * status-line countdown while retrying, raw JSON only on expand): any transient failure,
+ * which is a network drop, a 429 rate-limit, or a 5xx. Hard quota/auth/billing failures
+ * classify non-retryable here and stay verbose, because they need a credential or plan
+ * change, not a wait. Delegates to the shared classifier so the transcript decision and
+ * the retry engine never disagree about what is transient.
+ */
+export function isRetryableProviderError(raw) {
+    if (!raw)
+        return false;
+    if (isNetworkProviderError(raw))
+        return true;
+    return isRetryableErrorMessage(raw);
+}
 export function isNetworkProviderMessage(message) {
     return ((message.stopReason === "error" || message.stopReason === "aborted") &&
         isNetworkProviderError(message.errorMessage));
@@ -62,10 +78,12 @@ class ProviderFailureNotice {
 export class ProviderErrorPresentation {
     constructor(chat) {
         this.pending = false;
+        this.retryAwaitingFinish = false;
         this.chat = chat;
     }
     record(raw, expanded = false) {
         this.pending = true;
+        this.retryAwaitingFinish = true;
         if (!this.notice) {
             this.notice = new ProviderFailureNotice();
             this.notice.setExpanded(expanded);
@@ -78,17 +96,41 @@ export class ProviderErrorPresentation {
         // RetryStatusIndicator owns the single visible transient row.
         this.notice?.setSummary(undefined);
     }
+    /** A success or cleanup ends the episode: no finish is owed afterward. */
     clear() {
         this.pending = false;
+        this.retryAwaitingFinish = false;
         // Keep diagnostics reachable through the existing expansion affordance.
         this.notice?.setSummary(undefined);
     }
+    /**
+     * The retry engine finishing (summarization_retry_finished): clears the transient row but keeps
+     * the episode marker, because the terminal compaction_end that follows still closes the
+     * exhausted episode out via finish().
+     */
+    clearTransient() {
+        this.pending = false;
+        this.notice?.setSummary(undefined);
+    }
+    /** True while a retry episode is active (a retry was recorded and not yet finished/cleared). */
+    get hasActiveRetry() {
+        return this.pending;
+    }
+    /**
+     * True only while a retry has been recorded in the CURRENT episode and not yet closed out by
+     * finish(). A fresh terminal failure after an episode that already finished returns false, so
+     * it surfaces as a plain error instead of reopening the stale banner.
+     */
+    get awaitingRetryFinish() {
+        return this.retryAwaitingFinish;
+    }
     finish(raw, attempts) {
         if (raw)
             this.record(raw);
         if (!this.pending)
             return;
         this.pending = false;
+        this.retryAwaitingFinish = false;
         const count = attempts === undefined ? "" : ` after ${attempts} retries`;
         this.notice?.setSummary(`The model provider could not complete the request${count}. Try again or choose another model with /model.`);
     }

package/dist/modes/interactive/session-control-registry.js

@@ -11,6 +11,7 @@ import { createHash } from "node:crypto";
 import { rmSync } from "node:fs";
 import { chmod, lstat, mkdir, realpath, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { engineBuildIdentity } from "../../core/engine-build-identity.js";
 import { createDaemonDirectories, createHostDaemonPaths } from "../rpc/host-daemon-paths.js";
 import { thisProcessStartTime, writeHostRegistration } from "../rpc/host-daemon-registration.js";
 import { acquireHostEnsureLock } from "../rpc/host-ensure-lock.js";
@@ -64,6 +65,7 @@ export async function registerTuiEndpoint(options) {
             instanceId: options.instanceId,
             generation: 0,
             launchProfileId: "tui",
+            build: engineBuildIdentity(),
         });
         await createDaemonDirectories(paths, { kind: "tui" });
     }