pi-ui-extend 1.0.24 → 1.0.28

package/README.md

@@ -371,12 +371,16 @@ Both support the published schema:
       "apply_patch": { "defaultExpanded": true }
     }
   },
-  "promptEnhancer": { "modelRef": "zai/glm-5-turbo" },
+  "promptEnhancer": { "modelRef": "openai-codex/gpt-5.6-luna" },
   "autocomplete": {
     "modelRef": "zai/glm-5-turbo",
     "debounceMs": 350,
     "timeoutMs": 3000
   },
+  "sessionTitle": {
+    "modelRef": "openai-codex/gpt-5.6-luna",
+    "fallbackModels": ["zai/glm-5-turbo"]
+  },
   "dictation": { "language": "en" },
   "ignoreContextFiles": false,
   "maxProjectSessions": 0

package/dist/app/app.d.ts

@@ -36,6 +36,7 @@ export declare class PiUiExtendApp {
     private readonly popupMenus;
     private readonly voiceController;
     private readonly sessionEvents;
+    private readonly agentPauseController;
     private readonly shellController;
     private readonly queuedMessages;
     private readonly workspaceActions;

package/dist/app/app.js

@@ -31,6 +31,7 @@ import { AppSessionLifecycleController } from "./session/session-lifecycle-contr
 import { AppShellController } from "./commands/shell-controller.js";
 import { runInteractiveShellCommand } from "./commands/shell-command.js";
 import { AppSessionEventController } from "./session/session-event-controller.js";
+import { AgentPauseController } from "./session/agent-pause-controller.js";
 import { AppStatusController } from "./screen/status-controller.js";
 import { StatusLineRenderer } from "./rendering/status-line-renderer.js";
 import { AppModelUsageController } from "./model/model-usage-controller.js";
@@ -91,6 +92,7 @@ export class PiUiExtendApp {
     popupMenus;
     voiceController;
     sessionEvents;
+    agentPauseController;
     shellController;
     queuedMessages;
     workspaceActions;
@@ -167,6 +169,11 @@ export class PiUiExtendApp {
             runtimeSession: () => this.runtime?.session,
             render: () => this.scheduleRender(),
         });
+        this.agentPauseController = new AgentPauseController({
+            showToast: (message, kind) => this.showToast(message, kind),
+            render: () => this.scheduleRender(),
+            isCurrentSession: (session) => this.runtime?.session === session,
+        });
         this.modelUsageController = new AppModelUsageController({
             runtimeSession: () => this.runtime?.session,
             render: () => this.render(),
@@ -308,6 +315,8 @@ export class PiUiExtendApp {
             promptEnhancerStatusWidgetEnabled: () => this.promptEnhancer.statusWidgetEnabled(),
             terminalBellSoundStatusWidgetText: () => this.terminalBellSoundController.statusWidgetText(),
             terminalBellSoundStatusWidgetEnabled: () => this.terminalBellSoundController.isEnabled(),
+            agentPauseStatusWidgetText: () => this.agentPauseController.statusWidgetText(this.runtime?.session),
+            agentPauseStatusWidgetActive: () => this.agentPauseController.statusWidgetActive(this.runtime?.session),
             voiceStatusWidgetText: () => this.voiceController.statusWidgetText(),
             voiceStatusWidgetActive: () => this.voiceController.statusWidgetActive(),
             conversationQuickScrollDirections: () => this.conversationQuickScrollDirections(),
@@ -633,6 +642,7 @@ export class PiUiExtendApp {
                 this.render();
             },
             toggleTerminalBellSound: () => this.toggleTerminalBellSound(),
+            toggleAgentPause: () => this.agentPauseController.toggle(this.runtime?.session),
             handleExtensionInputMouse: (event) => this.extensionUiController.handleCustomUiMouse(event),
             render: () => this.render(),
         }, this.popupMenus, this.popupActions, this.scrollController, this.commandController);
@@ -783,6 +793,7 @@ export class PiUiExtendApp {
             createExtensionCommandContextActions: (runtime) => this.extensionActions.createCommandContextActions(runtime),
             handleExtensionError: (error) => this.extensionActions.handleExtensionError(error),
             handleSessionEvent: (event) => this.handleSessionEvent(event),
+            bindAgentPause: (session) => this.agentPauseController.bind(session),
             addEntry: (entry) => this.addEntry(entry),
             setStatus: (status) => this.setStatus(status),
             showToast: (message, kind) => this.showToast(message, kind),
@@ -809,6 +820,7 @@ export class PiUiExtendApp {
                 this.mouseController.statusTerminalBellSoundTarget = undefined;
                 this.mouseController.statusSessionTarget = undefined;
                 this.mouseController.statusPromptEnhancerTarget = undefined;
+                this.mouseController.statusAgentPauseTarget = undefined;
                 this.mouseController.statusVoiceMicTarget = undefined;
                 this.mouseController.statusVoiceLanguageTarget = undefined;
                 this.mouseController.tabLineTargets.length = 0;

package/dist/app/icons.d.ts

@@ -17,6 +17,7 @@ declare const NERD_FONT_ICONS: {
     readonly microphone: "󰍬";
     readonly plus: "󰐕";
     readonly pause: "󰏤";
+    readonly play: "󰐊";
     readonly record: "󰑊";
     readonly refresh: "󰑐";
     readonly volumeHigh: "󰕾";

package/dist/app/icons.js

@@ -28,6 +28,7 @@ const NERD_FONT_ICONS = {
     microphone: "\u{f036c}",
     plus: "\u{f0415}",
     pause: "\u{f03e4}",
+    play: "\u{f040a}",
     record: "\u{f044a}",
     refresh: "\u{f0450}",
     volumeHigh: "\u{f057e}",
@@ -61,6 +62,7 @@ const FALLBACK_ICONS = {
     microphone: "m",
     plus: "+",
     pause: "⏸",
+    play: "▶",
     record: "●",
     refresh: "↻",
     volumeHigh: "♪",

package/dist/app/input/input-controller.d.ts

@@ -9,6 +9,7 @@ export type InputControllerHost = {
     handleExtensionTerminalInput(data: string): ExtensionTerminalInputResult;
     extensionInputUsesEditor?(): boolean;
     isShiftPressed?(): boolean;
+    isCommandPressed?(): boolean;
     getInput(): string;
     getDirectPopupMenu(): DirectPopupMenu | undefined;
     resetRequestHistoryNavigation(): void;
@@ -68,5 +69,6 @@ export declare class AppInputController {
     private deleteCurrentInputLine;
     private handleChar;
     private isShiftPressed;
+    private isCommandPressed;
 }
 export {};

package/dist/app/input/input-controller.js

@@ -179,7 +179,7 @@ export class AppInputController {
                 break;
             // Native undo/redo shortcuts must retain their individual key behavior.
             const lower = char.toLowerCase();
-            if ((lower === "z" || lower === "y") && isNativeCommandPressed())
+            if ((lower === "z" || lower === "y") && this.isCommandPressed())
                 break;
             length += 1;
         }
@@ -417,7 +417,7 @@ export class AppInputController {
         return "consumed";
     }
     handleArrowUp() {
-        if (isNativeCommandPressed()) {
+        if (this.isCommandPressed()) {
             this.host.scrollByPage(-1);
             return;
         }
@@ -438,7 +438,7 @@ export class AppInputController {
         this.host.scrollByLines(-1);
     }
     handleArrowDown() {
-        if (isNativeCommandPressed()) {
+        if (this.isCommandPressed()) {
             this.host.scrollByPage(1);
             return;
         }
@@ -517,7 +517,7 @@ export class AppInputController {
                 this.redoInput();
             return true;
         }
-        if (!isNativeCommandPressed())
+        if (!this.isCommandPressed())
             return false;
         const lower = char.toLowerCase();
         if (lower === "z") {
@@ -595,7 +595,7 @@ export class AppInputController {
             this.host.handleEnter();
             return;
         }
-        if (char === "\u0015" || ((char === "\u007f" || char === "\b") && isNativeCommandPressed())) {
+        if (char === "\u0015" || ((char === "\u007f" || char === "\b") && this.isCommandPressed())) {
             this.deleteCurrentInputLine();
             return;
         }
@@ -625,6 +625,9 @@ export class AppInputController {
     isShiftPressed() {
         return this.host.isShiftPressed?.() ?? isNativeShiftPressed();
     }
+    isCommandPressed() {
+        return this.host.isCommandPressed?.() ?? isNativeCommandPressed();
+    }
 }
 function normalizeBracketedPastePayload(payload) {
     return payload.replace(/\r\n/g, "\n").replace(/\r/g, "\n");

package/dist/app/rendering/render-controller.js

@@ -73,6 +73,7 @@ export class AppRenderController {
         this.deps.mouseController.statusTerminalBellSoundTarget = undefined;
         this.deps.mouseController.statusSessionTarget = undefined;
         this.deps.mouseController.statusPromptEnhancerTarget = undefined;
+        this.deps.mouseController.statusAgentPauseTarget = undefined;
         this.deps.mouseController.statusVoiceMicTarget = undefined;
         this.deps.mouseController.statusVoiceLanguageTarget = undefined;
         this.deps.mouseController.tabLineTargets.length = 0;
@@ -284,6 +285,7 @@ export class AppRenderController {
         this.deps.mouseController.statusTerminalBellSoundTarget = this.deps.statusLineRenderer.terminalBellSoundTarget?.(statusLayout, statusRow);
         this.deps.mouseController.statusSessionTarget = this.deps.statusLineRenderer.sessionTarget(statusLayout.text, statusRow, statusLayout.sessionLabel, statusLayout.workspaceLabel);
         this.deps.mouseController.statusPromptEnhancerTarget = this.deps.statusLineRenderer.promptEnhancerTarget(statusLayout, statusRow);
+        this.deps.mouseController.statusAgentPauseTarget = this.deps.statusLineRenderer.agentPauseTarget?.(statusLayout, statusRow);
         this.deps.mouseController.statusVoiceMicTarget = this.deps.statusLineRenderer.voiceMicTarget(statusLayout, statusRow);
         this.deps.mouseController.statusVoiceLanguageTarget = this.deps.statusLineRenderer.voiceLanguageTarget(statusLayout, statusRow);
         this.deps.mouseController.renderedRowTexts.set(statusRow, statusLayout.text);

package/dist/app/rendering/status-line-renderer.d.ts

@@ -1,6 +1,6 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import type { Theme } from "../../theme.js";
-import type { SessionActivity, StatusCompactToolsTarget, StatusContextTarget, StatusDraftQueueTarget, StatusInternalClipboardTarget, StatusLineLayout, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusQuickScrollTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
+import type { SessionActivity, StatusAgentPauseTarget, StatusCompactToolsTarget, StatusContextTarget, StatusDraftQueueTarget, StatusInternalClipboardTarget, StatusLineLayout, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusQuickScrollTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
 import type { ScreenStyler } from "../screen/screen-styler.js";
 import { type ModelColorsConfig } from "../../config.js";
 export type StatusLineRendererHost = {
@@ -24,6 +24,8 @@ export type StatusLineRendererHost = {
     promptEnhancerStatusWidgetEnabled(): boolean;
     terminalBellSoundStatusWidgetText(): string;
     terminalBellSoundStatusWidgetEnabled(): boolean;
+    agentPauseStatusWidgetText?(): string;
+    agentPauseStatusWidgetActive?(): boolean;
     voiceStatusWidgetText(): string;
     voiceStatusWidgetActive(): boolean;
     conversationQuickScrollDirections?(): {
@@ -49,6 +51,7 @@ export declare class StatusLineRenderer {
     contextTarget(statusText: string, row: number, layout: StatusLineLayout): StatusContextTarget | undefined;
     modelUsageTarget(statusText: string, row: number, layout: StatusLineLayout): StatusModelUsageTarget | undefined;
     promptEnhancerTarget(layout: StatusLineLayout, row: number): StatusPromptEnhancerTarget | undefined;
+    agentPauseTarget(layout: StatusLineLayout, row: number): StatusAgentPauseTarget | undefined;
     voiceMicTarget(layout: StatusLineLayout, row: number): StatusVoiceMicTarget | undefined;
     voiceLanguageTarget(layout: StatusLineLayout, row: number): StatusVoiceLanguageTarget | undefined;
     userJumpTarget(layout: StatusLineLayout, row: number): StatusUserJumpTarget | undefined;

package/dist/app/rendering/status-line-renderer.js

@@ -91,6 +91,10 @@ export class StatusLineRenderer {
         appendWidget(quickScrollDirections.down ? this.iconButtonText(APP_ICONS.down) : "", (column, text) => {
             layout.quickScrollDownWidget = this.widgetLayout(column, text);
         });
+        const agentPauseWidgetText = this.host.agentPauseStatusWidgetText?.() ?? "";
+        appendWidget(agentPauseWidgetText ? this.iconButtonText(agentPauseWidgetText) : "", (column, text) => {
+            layout.agentPauseWidget = this.widgetLayout(column, text);
+        });
         const voiceWidgetText = this.host.voiceStatusWidgetText();
         appendWidget(this.voiceBorderWidgetText(voiceWidgetText), (column, text) => {
             layout.voiceWidget = this.voiceWidgetLayout(column, voiceWidgetText, text);
@@ -156,6 +160,7 @@ export class StatusLineRenderer {
         pushWidgetSegment(layout.terminalBellSoundWidget, this.host.terminalBellSoundStatusWidgetEnabled() ? colors.info : colors.muted);
         pushWidgetSegment(layout.thinkingExpandWidget, this.host.allThinkingExpandedActive?.() ? colors.info : colors.muted);
         pushWidgetSegment(layout.compactToolsWidget, this.host.superCompactToolsActive?.() ? colors.info : colors.muted);
+        pushWidgetSegment(layout.agentPauseWidget, this.host.agentPauseStatusWidgetActive?.() ? colors.info : colors.muted);
         const voiceWidget = layout.voiceWidget;
         if (voiceWidget) {
             segments.push({
@@ -229,6 +234,12 @@ export class StatusLineRenderer {
             return undefined;
         return { row, startColumn: widget.startColumn, endColumn: widget.endColumn };
     }
+    agentPauseTarget(layout, row) {
+        const widget = layout.agentPauseWidget;
+        if (!widget)
+            return undefined;
+        return { row, startColumn: widget.startColumn, endColumn: widget.endColumn };
+    }
     voiceMicTarget(layout, row) {
         const voiceWidget = layout.voiceWidget;
         if (!voiceWidget)
@@ -359,6 +370,7 @@ export class StatusLineRenderer {
             { widget: layout.terminalBellSoundWidget, foreground: this.host.terminalBellSoundStatusWidgetEnabled() ? colors.info : colors.muted },
             { widget: layout.thinkingExpandWidget, foreground: this.host.allThinkingExpandedActive?.() ? colors.info : colors.muted },
             { widget: layout.compactToolsWidget, foreground: this.host.superCompactToolsActive?.() ? colors.info : colors.muted },
+            { widget: layout.agentPauseWidget, foreground: this.host.agentPauseStatusWidgetActive?.() ? colors.info : colors.muted },
         ].filter((entry) => Boolean(entry.widget));
         for (const { widget, foreground } of widgets) {
             segments.push({

package/dist/app/screen/mouse-controller.d.ts

@@ -6,7 +6,7 @@ import type { ToastEntry, ToastVariant } from "../../ui.js";
 import type { AppPopupActionController } from "../popup/popup-action-controller.js";
 import type { AppPopupMenuController } from "../popup/popup-menu-controller.js";
 import type { AppScrollController } from "./scroll-controller.js";
-import type { Entry, ImageClickTarget, MouseEvent, MouseSelection, StatusContextTarget, StatusCompactToolsTarget, StatusDraftQueueTarget, StatusInternalClipboardTarget, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusQuickScrollTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, TabLineMouseTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
+import type { Entry, ImageClickTarget, MouseEvent, MouseSelection, StatusAgentPauseTarget, StatusContextTarget, StatusCompactToolsTarget, StatusDraftQueueTarget, StatusInternalClipboardTarget, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusQuickScrollTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, TabLineMouseTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
 import { type RenderedLink } from "./file-links.js";
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 type ClickFlash = {
@@ -63,6 +63,7 @@ export type AppMouseControllerHost = {
     toggleAllThinkingExpanded?(): void;
     toggleSuperCompactTools?(): void;
     toggleTerminalBellSound?(): void;
+    toggleAgentPause?(): void | Promise<void>;
     copyTextToClipboard?(text: string): void | Promise<void>;
     handleExtensionInputMouse(event: MouseEvent & {
         localRow: number;
@@ -114,6 +115,7 @@ export declare class AppMouseController {
     statusTerminalBellSoundTarget: StatusTerminalBellSoundTarget | undefined;
     statusSessionTarget: StatusSessionTarget | undefined;
     statusPromptEnhancerTarget: StatusPromptEnhancerTarget | undefined;
+    statusAgentPauseTarget: StatusAgentPauseTarget | undefined;
     statusVoiceMicTarget: StatusVoiceMicTarget | undefined;
     statusVoiceLanguageTarget: StatusVoiceLanguageTarget | undefined;
     readonly tabLineTargets: TabLineMouseTarget[];
@@ -172,6 +174,7 @@ export declare class AppMouseController {
     private handleStatusTerminalBellSoundClick;
     private handleStatusSessionClick;
     private handleStatusPromptEnhancerClick;
+    private handleStatusAgentPauseClick;
     private handleStatusVoiceMicClick;
     private handleStatusVoiceLanguageClick;
     private handleStatusQuickScrollClick;

package/dist/app/screen/mouse-controller.js

@@ -35,6 +35,7 @@ export class AppMouseController {
     statusTerminalBellSoundTarget;
     statusSessionTarget;
     statusPromptEnhancerTarget;
+    statusAgentPauseTarget;
     statusVoiceMicTarget;
     statusVoiceLanguageTarget;
     tabLineTargets = [];
@@ -333,6 +334,7 @@ export class AppMouseController {
             this.statusTerminalBellSoundTarget,
             this.statusSessionTarget,
             this.statusPromptEnhancerTarget,
+            this.statusAgentPauseTarget,
             this.statusVoiceMicTarget,
             this.statusVoiceLanguageTarget,
         ].find((candidate) => !!candidate
@@ -510,6 +512,7 @@ export class AppMouseController {
             || this.handleStatusCompactToolsClick(event)
             || this.handleStatusTerminalBellSoundClick(event)
             || this.handleStatusPromptEnhancerClick(event)
+            || this.handleStatusAgentPauseClick(event)
             || this.handleStatusVoiceMicClick(event)
             || this.handleStatusVoiceLanguageClick(event);
     }
@@ -570,6 +573,12 @@ export class AppMouseController {
         void this.host.enhancePrompt();
         return true;
     }
+    handleStatusAgentPauseClick(event) {
+        if (!this.statusTargetContains(this.statusAgentPauseTarget, event))
+            return false;
+        void this.host.toggleAgentPause?.();
+        return true;
+    }
     handleStatusVoiceMicClick(event) {
         if (!this.statusTargetContains(this.statusVoiceMicTarget, event))
             return false;

package/dist/app/session/agent-pause-controller.d.ts

@@ -0,0 +1,30 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+export type AgentPauseState = "idle" | "pause-requested" | "paused" | "resuming";
+export type AgentPauseControllerHost = {
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    render(): void;
+    isCurrentSession(session: AgentSession): boolean;
+};
+/**
+ * Implements a turn-boundary pause without interrupting an active tool batch.
+ *
+ * The pinned SDK exposes Agent.shouldStopAfterTurn and Agent.continue(), but not a
+ * session-level continuation method. The small private adapter below mirrors the
+ * bookkeeping in AgentSession._runAgentPrompt so resumed runs still get retries,
+ * compaction, queue draining, isStreaming, and agent_settled behavior.
+ */
+export declare class AgentPauseController {
+    private readonly host;
+    private readonly records;
+    constructor(host: AgentPauseControllerHost);
+    bind(session: AgentSession): void;
+    state(session: AgentSession | undefined): AgentPauseState;
+    statusWidgetText(session: AgentSession | undefined): string;
+    statusWidgetActive(session: AgentSession | undefined): boolean;
+    toggle(session: AgentSession | undefined): Promise<void>;
+    private resume;
+    private setState;
+    private finishSettlement;
+    private canContinue;
+    private sessionInternals;
+}

package/dist/app/session/agent-pause-controller.js

@@ -0,0 +1,178 @@
+import { APP_ICONS } from "../icons.js";
+/**
+ * Implements a turn-boundary pause without interrupting an active tool batch.
+ *
+ * The pinned SDK exposes Agent.shouldStopAfterTurn and Agent.continue(), but not a
+ * session-level continuation method. The small private adapter below mirrors the
+ * bookkeeping in AgentSession._runAgentPrompt so resumed runs still get retries,
+ * compaction, queue draining, isStreaming, and agent_settled behavior.
+ */
+export class AgentPauseController {
+    host;
+    records = new WeakMap();
+    constructor(host) {
+        this.host = host;
+    }
+    bind(session) {
+        if (this.records.has(session))
+            return;
+        const internals = this.sessionInternals(session);
+        const record = {
+            state: "idle",
+            pauseBoundaryReached: false,
+            originalHandlePostAgentRun: internals._handlePostAgentRun.bind(session),
+        };
+        this.records.set(session, record);
+        session.subscribe((event) => {
+            if (event.type === "agent_start" && record.state === "paused") {
+                // A new prompt supersedes a paused continuation.
+                this.setState(record, "idle");
+            }
+        });
+        const originalEmitAgentSettled = internals._emitAgentSettled.bind(session);
+        internals._emitAgentSettled = async () => {
+            try {
+                await originalEmitAgentSettled();
+            }
+            finally {
+                this.finishSettlement(record);
+            }
+        };
+        const originalShouldStopAfterTurn = session.agent.shouldStopAfterTurn;
+        const shouldStopAfterTurn = async (context, signal) => {
+            if (await originalShouldStopAfterTurn?.(context, signal)) {
+                if (record.state === "pause-requested") {
+                    record.pauseBoundaryReached = false;
+                    this.setState(record, "idle");
+                }
+                return true;
+            }
+            if (record.state !== "pause-requested")
+                return false;
+            record.pauseBoundaryReached = true;
+            return true;
+        };
+        session.agent.shouldStopAfterTurn = shouldStopAfterTurn;
+        internals._handlePostAgentRun = async () => {
+            if (record.state === "paused")
+                return false;
+            const pauseBoundaryReached = record.pauseBoundaryReached;
+            record.pauseBoundaryReached = false;
+            const shouldContinue = await record.originalHandlePostAgentRun();
+            if (pauseBoundaryReached || record.state === "pause-requested") {
+                if (shouldContinue || this.canContinue(session)) {
+                    record.pauseSettled = new Promise((resolve) => {
+                        record.resolvePauseSettled = resolve;
+                    });
+                    this.setState(record, "paused");
+                    this.host.showToast("Agent paused after the current turn", "success");
+                    return false;
+                }
+                this.setState(record, "idle");
+                return false;
+            }
+            return shouldContinue;
+        };
+    }
+    state(session) {
+        if (!session)
+            return "idle";
+        return this.records.get(session)?.state ?? "idle";
+    }
+    statusWidgetText(session) {
+        return this.state(session) === "paused" ? APP_ICONS.play : APP_ICONS.pause;
+    }
+    statusWidgetActive(session) {
+        if (!session)
+            return false;
+        return this.state(session) !== "idle" || session.isStreaming || session.agent.state.isStreaming;
+    }
+    async toggle(session) {
+        if (!session) {
+            this.host.showToast("No active agent session", "info");
+            return;
+        }
+        this.bind(session);
+        const record = this.records.get(session);
+        if (record.state === "paused") {
+            await this.resume(session, record);
+            return;
+        }
+        if (record.state === "pause-requested" || record.state === "resuming")
+            return;
+        if (!session.isStreaming && !session.agent.state.isStreaming) {
+            this.host.showToast("Agent is not running", "info");
+            return;
+        }
+        this.setState(record, "pause-requested");
+        this.host.showToast("Pause requested; waiting for the current turn to finish", "info");
+    }
+    async resume(session, record) {
+        this.setState(record, "resuming");
+        this.host.showToast("Continuing agent", "info");
+        try {
+            // isIdle becomes true before async agent_settled extension handlers finish,
+            // so wait for the event itself rather than relying on waitForIdle().
+            await record.pauseSettled;
+            if (!this.host.isCurrentSession(session)) {
+                throw new Error("agent session changed before it could continue");
+            }
+            const internals = this.sessionInternals(session);
+            internals._isAgentRunActive = true;
+            try {
+                // Continue exactly as AgentSession._runAgentPrompt would.
+                await session.agent.continue();
+                while (this.host.isCurrentSession(session)) {
+                    const shouldContinue = await record.originalHandlePostAgentRun();
+                    if (!shouldContinue || !this.host.isCurrentSession(session))
+                        break;
+                    await session.agent.continue();
+                }
+            }
+            finally {
+                internals._systemPromptOverride = undefined;
+                internals._flushPendingBashMessages();
+                await internals._emitAgentSettled();
+            }
+        }
+        catch (error) {
+            this.setState(record, "paused");
+            this.host.showToast(`Could not continue agent: ${errorMessage(error)}`, "error");
+            return;
+        }
+        this.setState(record, "idle");
+    }
+    setState(record, state) {
+        if (record.state === state)
+            return;
+        record.state = state;
+        this.host.render();
+    }
+    finishSettlement(record) {
+        record.resolvePauseSettled?.();
+        delete record.resolvePauseSettled;
+        if (record.state === "pause-requested") {
+            record.pauseBoundaryReached = false;
+            this.setState(record, "idle");
+        }
+    }
+    canContinue(session) {
+        const messages = session.agent.state.messages;
+        const lastMessage = messages[messages.length - 1];
+        return Boolean(lastMessage && lastMessage.role !== "assistant") || session.agent.hasQueuedMessages();
+    }
+    sessionInternals(session) {
+        const internals = session;
+        if (typeof internals._handlePostAgentRun !== "function"
+            || typeof internals._flushPendingBashMessages !== "function"
+            || typeof internals._emitAgentSettled !== "function"
+            || typeof internals._isAgentRunActive !== "boolean"
+            || !("_systemPromptOverride" in internals)) {
+            throw new Error("Agent pause is incompatible with this pi SDK version");
+        }
+        return internals;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/app/session/session-event-controller.d.ts

@@ -144,6 +144,7 @@ export declare class AppSessionEventController {
     touchEntry(entry: Entry): void;
     addEntry(entry: Entry): void;
     prependEntries(entries: readonly Entry[]): void;
+    private prependLoadedHistoryEntries;
     private shiftHistoryWindow;
     private setHistoryWindowStart;
     private historyWindowSize;

package/dist/app/session/session-event-controller.js

@@ -134,7 +134,8 @@ export class AppSessionEventController {
         this.historyEntries = [];
         this.historyWindowStart = 0;
         const lazyOlderHistory = options.lazyOlderHistory === true;
-        const historyEntries = lazyOlderHistory ? undefined : [];
+        const historyEntries = [];
+        let historyAttached = false;
         const messages = lazyOlderHistory
             ? sessionHistoryDisplayMessages(runtime.session)
             : sessionHistoryDisplayMessagesFromEntries(await sessionHistoryFullBranchEntries(runtime.session));
@@ -142,24 +143,22 @@ export class AppSessionEventController {
             return false;
         const loaded = await loadSessionHistoryEntriesAsync({
             messages,
-            addEntry: (entry) => {
-                if (historyEntries)
-                    historyEntries.push(entry);
-                else
-                    this.addEntry(entry);
-            },
+            addEntry: (entry) => historyEntries.push(entry),
             prependEntries: (entries) => {
-                if (historyEntries)
-                    historyEntries.unshift(...entries);
+                if (historyAttached)
+                    this.prependLoadedHistoryEntries(entries);
                 else
-                    this.prependEntries(entries);
+                    historyEntries.unshift(...entries);
             },
             setToolEntryId: (toolCallId, entryId) => this.toolEntryIdsByCallId.set(toolCallId, entryId),
             toolDefaultExpanded: (toolName) => this.host.toolDefaultExpanded(toolName),
             observeSubagentsToolResult: (toolName, details, options) => this.host.observeSubagentsToolResult(toolName, details, options),
             observeTodoToolResult: (toolName, details, isError) => this.host.observeTodoToolResult(toolName, details, isError),
             isCancelled: options.isCancelled,
-            render: lazyOlderHistory ? options.render : () => { },
+            render: () => {
+                if (historyAttached)
+                    options.render();
+            },
             lazyOlderHistory,
             olderMessagesReader: lazyOlderHistory ? sessionHistoryOlderMessagesReader(runtime.session) : undefined,
             onOlderLoaderReady: (loader) => {
@@ -169,24 +168,24 @@ export class AppSessionEventController {
         });
         if (!loaded)
             return false;
-        if (!historyEntries)
-            return !options.isCancelled();
         this.historyEntries = historyEntries;
+        historyAttached = true;
         this.setHistoryWindowStart(this.maxHistoryWindowStart());
         options.render();
         return !options.isCancelled();
     }
     hasOlderSessionHistory() {
         if (this.historyEntries.length > 0)
-            return this.historyWindowStart > 0;
+            return this.historyWindowStart > 0 || this.olderHistoryLoader?.hasOlder() === true;
         return this.olderHistoryLoader?.hasOlder() === true;
     }
     isLoadingOlderSessionHistory() {
         return this.olderHistoryLoader?.isLoading() === true;
     }
     async loadOlderSessionHistory(options = {}) {
-        if (this.historyEntries.length > 0)
+        if (this.historyEntries.length > 0 && this.historyWindowStart > 0) {
             return this.shiftHistoryWindow(-HISTORY_WINDOW_SHIFT_ENTRIES, options);
+        }
         return this.olderHistoryLoader?.loadOlder(options) ?? false;
     }
     /**
@@ -447,6 +446,14 @@ export class AppSessionEventController {
             this.registerEntry(entry);
         this.pruneHistoryWindow("bottom");
     }
+    prependLoadedHistoryEntries(entries) {
+        if (entries.length === 0)
+            return;
+        const previousStart = this.historyWindowStart;
+        this.historyEntries.unshift(...entries);
+        const nextStart = previousStart === 0 ? 0 : previousStart + entries.length;
+        this.setHistoryWindowStart(nextStart);
+    }
     shiftHistoryWindow(delta, options = {}) {
         if (this.historyEntries.length === 0)
             return false;

package/dist/app/session/session-lifecycle-controller.d.ts

@@ -26,6 +26,7 @@ export type AppSessionLifecycleHost = {
     createExtensionCommandContextActions(runtime: AgentSessionRuntime): ExtensionCommandContextActions;
     handleExtensionError(error: ExtensionError): void;
     handleSessionEvent(event: AgentSessionEvent): void;
+    bindAgentPause(session: AgentSession): void;
     addEntry(entry: Entry): void;
     setStatus(status: string): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;

package/dist/app/session/session-lifecycle-controller.js

@@ -73,6 +73,7 @@ export class AppSessionLifecycleController {
     async bindCurrentSession(options = {}) {
         const runtime = this.requireRuntime();
         const session = runtime.session;
+        this.host.bindAgentPause(session);
         const ownershipGeneration = this.advanceOwnership(runtime, session);
         const subscriptionGeneration = ++this.subscriptionGeneration;
         this.replacementHistoryGeneration += 1;