pi-ui-extend 0.1.77 → 1.0.1

package/dist/app/app.js

@@ -387,6 +387,7 @@ export class PiUiExtendApp {
         this.sessionEvents = new AppSessionEventController({
             entries: this.entries,
             runtime: () => this.runtime,
+            awaitSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             conversationViewport: () => this.conversationViewport,
             conversationViewportColumns: () => this.terminalColumns(),
             onHistoryWindowPruned: (edge, lineCount) => this.scrollController.adjustForHistoryWindowPrune(edge, lineCount),
@@ -421,6 +422,7 @@ export class PiUiExtendApp {
         this.queuedMessages = new AppQueuedMessageController({
             runtime: () => this.runtime,
             requireRuntime: () => this.requireRuntime(),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             visibleEntries: () => this.conversationViewport.entries(),
             isRunning: () => this.running,
             render: () => this.render(),
@@ -605,6 +607,7 @@ export class PiUiExtendApp {
             toastEntry: (toastId) => this.toastController.entry(toastId),
             showToast: (message, kind, options) => this.showToast(message, kind, options),
             dismissToast: (toastId) => this.toastController.dismissToast(toastId),
+            activateToastAction: (toastId) => this.toastController.activateAction(toastId),
             refreshModelUsageStatus: () => this.refreshModelUsageStatusFromClick(),
             refreshUserMessageJumpMenuItems: () => this.menuItems.refreshUserMessageJumpMenuItems(),
             queueInputFromStatus: () => {

package/dist/app/rendering/toast-controller.d.ts

@@ -1,4 +1,19 @@
 import { type ToastEntry, type ToastKind, type ToastVariant } from "../../ui.js";
+export type AppToastEntry = ToastEntry & {
+    action?: {
+        label: string;
+    };
+};
+export type AppToastAction = {
+    label: string;
+    onSelect: () => void;
+};
+export type AppToastOptions = {
+    durationMs?: number;
+    variant?: ToastVariant;
+    scopeKey?: string;
+    action?: AppToastAction;
+};
 export type AppToastControllerHost = {
     activeScope?(): string | undefined;
     render(): void;
@@ -7,19 +22,19 @@ export declare class AppToastController {
     private readonly host;
     private readonly toastsByScope;
     private readonly timers;
+    private readonly actions;
     constructor(host: AppToastControllerHost);
-    showToast(message: string, kind?: ToastKind, options?: {
-        durationMs?: number;
-        variant?: ToastVariant;
-        scopeKey?: string;
-    }): void;
+    showToast(message: string, kind?: ToastKind, options?: AppToastOptions): void;
     dismissToast(toastId: number, scopeKey?: string): void;
+    activateAction(toastId: number, scopeKey?: string): boolean;
     dismissActiveDialog(scopeKey?: string): boolean;
-    visibleStates(scopeKey?: string): readonly ToastEntry[];
+    visibleStates(scopeKey?: string): readonly AppToastEntry[];
     entry(toastId: number, scopeKey?: string): ToastEntry | undefined;
     clearToastTimers(): void;
     private toastForScope;
     private timersForScope;
+    private actionsForScope;
+    private removeAction;
     private deleteScopeIfEmpty;
     private normalizeScopeKey;
 }

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

@@ -4,13 +4,17 @@ export class AppToastController {
     host;
     toastsByScope = new Map();
     timers = new Map();
+    actions = new Map();
     constructor(host) {
         this.host = host;
     }
     showToast(message, kind = "info", options = {}) {
         const scopeKey = this.normalizeScopeKey(options.scopeKey ?? this.host.activeScope?.());
         const toast = this.toastForScope(scopeKey);
+        const action = options.variant === "dialog" ? undefined : options.action;
         const toastId = toast.show(message, kind, options.variant ? { variant: options.variant } : {});
+        if (action)
+            this.actionsForScope(scopeKey).set(toastId, action);
         if (kind === "error" || options.variant === "dialog") {
             this.host.render();
             return;
@@ -21,6 +25,7 @@ export class AppToastController {
         const timer = setTimeout(() => {
             toast.hide(toastId);
             this.timers.get(scopeKey)?.delete(toastId);
+            this.removeAction(scopeKey, toastId);
             this.deleteScopeIfEmpty(scopeKey);
             this.host.render();
         }, durationMs);
@@ -36,9 +41,18 @@ export class AppToastController {
             timers?.delete(toastId);
         }
         this.toastsByScope.get(scopeKey)?.hide(toastId);
+        this.removeAction(scopeKey, toastId);
         this.deleteScopeIfEmpty(scopeKey);
         this.host.render();
     }
+    activateAction(toastId, scopeKey = this.normalizeScopeKey(this.host.activeScope?.())) {
+        const action = this.actions.get(scopeKey)?.get(toastId);
+        if (!action)
+            return false;
+        this.dismissToast(toastId, scopeKey);
+        action.onSelect();
+        return true;
+    }
     dismissActiveDialog(scopeKey = this.normalizeScopeKey(this.host.activeScope?.())) {
         const states = this.visibleStates(scopeKey);
         let dialog;
@@ -57,7 +71,14 @@ export class AppToastController {
         return true;
     }
     visibleStates(scopeKey = this.normalizeScopeKey(this.host.activeScope?.())) {
-        return this.toastsByScope.get(scopeKey)?.visibleStates ?? [];
+        const states = this.toastsByScope.get(scopeKey)?.visibleStates ?? [];
+        const actions = this.actions.get(scopeKey);
+        if (!actions || actions.size === 0)
+            return states;
+        return states.map((state) => {
+            const action = actions.get(state.id);
+            return action ? { ...state, action: { label: action.label } } : state;
+        });
     }
     entry(toastId, scopeKey = this.normalizeScopeKey(this.host.activeScope?.())) {
         return this.toastsByScope.get(scopeKey)?.entry(toastId);
@@ -68,6 +89,7 @@ export class AppToastController {
                 clearTimeout(timer);
         }
         this.timers.clear();
+        this.actions.clear();
         for (const toast of this.toastsByScope.values())
             toast.hide();
         this.toastsByScope.clear();
@@ -88,6 +110,20 @@ export class AppToastController {
         }
         return timers;
     }
+    actionsForScope(scopeKey) {
+        let actions = this.actions.get(scopeKey);
+        if (!actions) {
+            actions = new Map();
+            this.actions.set(scopeKey, actions);
+        }
+        return actions;
+    }
+    removeAction(scopeKey, toastId) {
+        const actions = this.actions.get(scopeKey);
+        actions?.delete(toastId);
+        if (actions?.size === 0)
+            this.actions.delete(scopeKey);
+    }
     deleteScopeIfEmpty(scopeKey) {
         const timers = this.timers.get(scopeKey);
         if (timers && timers.size === 0)

package/dist/app/rendering/toast-renderer.d.ts

@@ -1,6 +1,6 @@
 import { type Theme } from "../../theme.js";
-import type { ToastEntry } from "../../ui.js";
 import type { ToastLineTarget } from "../types.js";
+import type { AppToastEntry } from "./toast-controller.js";
 export type ToastOverlay = {
     id: number;
     row: number;
@@ -9,4 +9,4 @@ export type ToastOverlay = {
     output: string;
     target?: ToastLineTarget;
 };
-export declare function renderToastOverlays(states: readonly ToastEntry[], width: number, maxRows: number, theme: Theme): ToastOverlay[];
+export declare function renderToastOverlays(states: readonly AppToastEntry[], width: number, maxRows: number, theme: Theme): ToastOverlay[];

package/dist/app/rendering/toast-renderer.js

@@ -15,10 +15,13 @@ export function renderToastOverlays(states, width, maxRows, theme) {
         }
         const icon = toastKindIcon(state.kind);
         const lines = toastMessageLines(state.message, icon, Math.max(1, width - 6));
-        const visibleLines = lines.slice(0, Math.max(0, maxRows - overlays.length));
+        const availableRows = Math.max(0, maxRows - overlays.length);
+        const actionLabel = compactToastActionLabel(state);
+        const includeAction = actionLabel !== undefined && availableRows >= 2;
+        const visibleLines = lines.slice(0, Math.max(0, availableRows - (includeAction ? 1 : 0)));
         if (visibleLines.length === 0)
             continue;
-        const contentWidth = Math.max(...visibleLines.map((line) => stringDisplayWidth(line)));
+        const contentWidth = Math.max(...visibleLines.map((line) => stringDisplayWidth(line)), ...(includeAction ? [stringDisplayWidth(actionLabel)] : []));
         const toastWidth = Math.min(Math.max(12, contentWidth + 2), Math.max(1, width - 4));
         const leftWidth = Math.max(0, width - toastWidth - 2);
         const column = leftWidth + 1;
@@ -39,9 +42,39 @@ export function renderToastOverlays(states, width, maxRows, theme) {
                 target: { kind: "toast", id: state.id, action: "toast", startColumn: column, endColumn: column + toastWidth },
             });
         }
+        if (includeAction) {
+            const innerWidth = Math.max(0, toastWidth - 2);
+            const renderedLabel = padOrTrimPlain(actionLabel, innerWidth).trimEnd();
+            const labelWidth = stringDisplayWidth(renderedLabel);
+            if (labelWidth > 0) {
+                const leftPadding = Math.max(0, innerWidth - labelWidth);
+                const message = ` ${" ".repeat(leftPadding)}${renderedLabel} `;
+                const startColumn = column + 1 + leftPadding;
+                overlays.push({
+                    id: state.id,
+                    row: overlays.length + 1,
+                    column,
+                    text: padOrTrimPlain(message, toastWidth),
+                    output: colorToastLine(message, toastWidth, { ...style, bold: true }),
+                    target: {
+                        kind: "toast",
+                        id: state.id,
+                        action: "action",
+                        startColumn,
+                        endColumn: startColumn + labelWidth,
+                    },
+                });
+            }
+        }
     }
     return overlays;
 }
+function compactToastActionLabel(state) {
+    if (!state.action)
+        return undefined;
+    const label = stripToastAnsi(sanitizeToastText(state.action.label)).split("\n", 1)[0]?.trim();
+    return label ? `[${label}]` : undefined;
+}
 function toastMessageLines(message, icon, maxWidth) {
     const firstPrefix = `${icon} `;
     const continuationPrefix = " ".repeat(stringDisplayWidth(firstPrefix));

package/dist/app/runtime.d.ts

@@ -1,4 +1,4 @@
-import { SessionManager, type EventBus, type AgentSessionRuntime, type LoadExtensionsResult, type SessionEntry } from "@earendil-works/pi-coding-agent";
+import { SessionManager, type EventBus, type AgentSessionRuntime, type AgentSessionServices, type LoadExtensionsResult, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { type PixConfig } from "../config.js";
 import type { AppOptions, ThinkingLevel } from "./types.js";
 export type PiToolsSuiteInstallAction = "installed" | "already-installed" | "existing-kept" | "missing-source";
@@ -46,5 +46,6 @@ type RuntimeSessionManagerModelState = Pick<SessionManager, "getEntries" | "getB
 export declare function resolvePixRuntimeModelRef(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config?: PixConfig): string | undefined;
 export declare function resolvePixRuntimeInitialThinkingLevel(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config: PixConfig): ThinkingLevel | undefined;
 export declare function resolveSessionModelRefFromTail(entries: readonly SessionEntry[]): string | undefined;
+export declare function refreshPixModelRuntimeForStartup(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "refresh">): Promise<void>;
 export declare function createPixRuntime(options: AppOptions, runtimeOptions?: CreatePixRuntimeOptions): Promise<AgentSessionRuntime>;
 export {};

package/dist/app/runtime.js

@@ -235,6 +235,11 @@ export function resolveSessionModelRefFromTail(entries) {
         return undefined;
     return thinkingLevel ? `${modelRef}:${thinkingLevel}` : modelRef;
 }
+export async function refreshPixModelRuntimeForStartup(modelRuntime) {
+    // Startup only needs the locally configured model catalog. Remote catalog
+    // refreshes belong to explicit model-management flows and must not block boot.
+    await modelRuntime.refresh({ allowNetwork: false });
+}
 export async function createPixRuntime(options, runtimeOptions = {}) {
     const agentDir = getAgentDir();
     const reusableServices = reusableRuntimeServices(runtimeOptions.reuseServicesFrom, options.cwd, agentDir);
@@ -256,7 +261,7 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
                 config,
                 ...(runtimeOptions.eventBus === undefined ? {} : { eventBus: runtimeOptions.eventBus }),
             });
-        await services.modelRuntime.refresh();
+        await refreshPixModelRuntimeForStartup(services.modelRuntime);
         const model = parsedModel ? services.modelRuntime.getModel(parsedModel.provider, parsedModel.modelId) : undefined;
         if (parsedModel && !model) {
             throw new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);

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

@@ -53,6 +53,7 @@ export type AppMouseControllerHost = {
         variant?: ToastVariant;
     }): void;
     dismissToast(toastId: number): void;
+    activateToastAction(toastId: number): boolean;
     refreshModelUsageStatus(): void | Promise<void>;
     refreshUserMessageJumpMenuItems?(): Promise<void>;
     queueInputFromStatus?(): void | Promise<void>;

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

@@ -117,6 +117,11 @@ export class AppMouseController {
                 return;
             if (target.action === "body")
                 return;
+            if (target.action === "action") {
+                if (this.host.activateToastAction(target.id))
+                    this.showClickFlashForEvent(event);
+                return;
+            }
             if (this.copyErrorToast(target.id)) {
                 this.showClickFlashForEvent(event);
                 return;

package/dist/app/session/queued-message-controller.d.ts

@@ -4,6 +4,7 @@ import type { Entry, SessionActivity, SubmittedUserMessage } from "../types.js";
 export type AppQueuedMessageControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     requireRuntime(): AgentSessionRuntime;
+    awaitCurrentSessionExtensions(runtime: AgentSessionRuntime): Promise<void>;
     visibleEntries(): readonly Entry[];
     isRunning(): boolean;
     render(): void;

package/dist/app/session/queued-message-controller.js

@@ -59,6 +59,9 @@ export class AppQueuedMessageController {
             this.promptSubmissionsInFlight.add(targetSession);
         this.host.setSessionActivity("running");
         try {
+            const runtime = this.host.runtime();
+            if (runtime?.session === targetSession)
+                await this.host.awaitCurrentSessionExtensions(runtime);
             const opts = {};
             if (targetSession.isStreaming)
                 opts.streamingBehavior = options.streamingBehavior ?? "steer";

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

@@ -29,6 +29,7 @@ export type AppSessionEventControllerState = {
 export type AppSessionEventControllerHost = {
     readonly entries: Entry[];
     runtime(): AgentSessionRuntime | undefined;
+    awaitSessionExtensions?(runtime: AgentSessionRuntime): Promise<void>;
     conversationViewport(): ConversationViewport;
     conversationViewportColumns?(): number;
     onHistoryWindowPruned?(edge: "top" | "bottom", lineCount: number): void;
@@ -63,7 +64,12 @@ export type AppSessionEventControllerHost = {
         showSnapshot?: boolean;
     }): void;
     observeTodoToolResult(toolName: string, details: unknown, isError?: boolean): void;
-    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info", options?: {
+        action?: {
+            label: string;
+            onSelect: () => void;
+        };
+    }): void;
 };
 export declare class AppSessionEventController {
     private readonly host;
@@ -118,6 +124,9 @@ export declare class AppSessionEventController {
         render?: boolean;
     }): Promise<boolean>;
     handleSessionEvent(event: AgentSessionEvent): void;
+    private retryFailedTurn;
+    private retryFailedTurnAsync;
+    private isActiveRuntimeSession;
     addCustomMessageEntry(message: Record<string, unknown>): void;
     findEntry(id: string): Entry | undefined;
     findUserEntry(id: string): Extract<Entry, {

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

@@ -328,18 +328,70 @@ export class AppSessionEventController {
                 this.host.setStatus(`retry ${event.attempt}/${event.maxAttempts}`);
                 this.host.emitExtensionEvent(RETRY_ACTIVE_EVENT, { active: true });
                 break;
-            case "auto_retry_end":
+            case "auto_retry_end": {
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 this.host.restoreSessionStatus();
                 this.host.flushAutoUserMessages();
                 this.host.emitExtensionEvent(RETRY_ACTIVE_EVENT, { active: false });
-                this.host.showToast(event.success ? "Retry succeeded" : `Retry failed: ${event.finalError}`, event.success ? "success" : "error");
+                if (event.success) {
+                    this.host.showToast("Retry succeeded", "success");
+                    break;
+                }
+                const session = this.host.runtime()?.session;
+                this.host.showToast(`Retry failed: ${event.finalError}`, "error", session
+                    ? { action: { label: "Retry", onSelect: () => this.retryFailedTurn(session) } }
+                    : undefined);
                 break;
+            }
             default:
                 break;
         }
         this.host.scheduleRender();
     }
+    retryFailedTurn(session) {
+        void this.retryFailedTurnAsync(session);
+    }
+    async retryFailedTurnAsync(session) {
+        const runtime = this.host.runtime();
+        if (!runtime || !this.isActiveRuntimeSession(runtime, session))
+            return;
+        if (session.isStreaming || session.isCompacting) {
+            this.host.showToast("Retry is unavailable while the session is busy", "warning");
+            return;
+        }
+        this.host.setStatus("retrying failed turn");
+        this.host.setSessionActivity("running");
+        this.host.render();
+        try {
+            await this.host.awaitSessionExtensions?.(runtime);
+            if (!this.isActiveRuntimeSession(runtime, session))
+                return;
+            if (session.isStreaming || session.isCompacting) {
+                this.host.showToast("Retry is unavailable while the session is busy", "warning");
+                return;
+            }
+            await session.sendCustomMessage({
+                customType: "pix-retry",
+                content: "Continue the previous task from where you stopped.",
+                display: false,
+            }, { triggerTurn: true });
+        }
+        catch (error) {
+            if (this.isActiveRuntimeSession(runtime, session)) {
+                this.host.showToast(`Retry could not start: ${stringifyUnknown(error)}`, "error");
+            }
+        }
+        finally {
+            if (this.isActiveRuntimeSession(runtime, session)) {
+                this.host.setSessionStatus(session);
+                this.host.setSessionActivity(session.isStreaming || session.isCompacting ? "running" : "idle");
+                this.host.render();
+            }
+        }
+    }
+    isActiveRuntimeSession(runtime, session) {
+        return this.host.isRunning() && this.host.runtime() === runtime && runtime.session === session;
+    }
     addCustomMessageEntry(message) {
         const entry = customMessageEntry(message);
         if (entry)

package/dist/app/types.d.ts

@@ -243,7 +243,7 @@ export type RenderedLine = {
 export type ToastLineTarget = {
     kind: "toast";
     id: number;
-    action?: "toast" | "body" | "close";
+    action?: "toast" | "body" | "close" | "action";
     startColumn?: number;
     endColumn?: number;
 };

package/external/pi-tools-suite/src/tool-descriptions.ts

@@ -221,10 +221,10 @@ export const TODO_TOOL_DESCRIPTION: ToolDescription = {
 		"Use `todo` for complex work with 3+ steps, explicit user task lists, or new non-trivial requirements. Skip single trivial tasks and purely conversational requests.",
 		"For multi-step implementation/debugging plans, include a final user-facing report todo in the initial plan with acceptance criteria for changed files/behavior, verification results, and remaining manual actions; close it immediately before the final response, never via compression.",
 		"When create or batch_create already sets the intended status, do not issue a redundant update with the same status; continue the work instead.",
-		"Resync before continuing when user/new findings change scope, requirements, safety, feasibility, approach, dependencies, or order; update tasks/blockers and defer obsolete work.",
+		"Resync before continuing when user/new findings change scope, requirements, safety, feasibility, approach, dependencies, or order. Before creating tasks, review pending/deferred todos; when work resumes, reactivate and reuse an equivalent deferred todo instead of duplicating it.",
 		"Update todos when starting, finishing, blocking, splitting, abandoning, or materially changing a step; before planned work mark exactly one in_progress with activeForm and complete it only after verification.",
 		"If partial, tests fail, or blocked, keep the task in_progress and add/update a blocker. Never use `clear`, `delete`, or batch deletion to hide unfinished/stale/forgotten todos; delete only on explicit request or creation mistake.",
-		"Before a final response after using todos, ensure each visible todo is completed, deferred, or intentionally still in_progress with explanation; do not leave a just-finished item in_progress.",
+		"Before a final response, list and reconcile all visible todos, including deferred ones: complete any whose outcome was achieved elsewhere, and leave deferred only genuinely unfinished or intentionally out of scope, mentioning each in the response. Do not finish with stale/duplicate deferred todos or a just-finished item in_progress.",
 		"Keep subjects short; use parentId/blockers for hierarchy/dependencies. For large explicit plans use batch_create/batch_update but keep exactly one visible in_progress unless asked otherwise; use batch_create replace:true only for superseding plans.",
 		"list hides tombstones unless includeDeleted:true; use status/blockedOnly only when needed; export/import for handoff, import replace:true only when explicitly overwriting; when all visible todos complete, state clears automatically.",
 		"Persistence: `/todos persist on|off|status` or `/todos-persist on|off|status`; on resume, ask in-scope ids and run `/todos scope <id...>` or `/todos-scope <id...>` so out-of-scope active tasks are deferred.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.77",
+  "version": "1.0.1",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {