pi-ui-extend 0.1.78 → 1.0.2

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/rendering/tool-block-renderer.js

@@ -27,39 +27,34 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const headerPrefix = headerLabel ? `${stateIcon} ${headerLabel}` : stateIcon;
     const headerArgs = formatToolHeaderArgs(entry.headerArgs);
     const headerArgsWidth = width - stringDisplayWidth(headerPrefix) - 1;
-    const clippedHeaderArgs = headerArgsWidth > 0 ? sliceByDisplayWidth(headerArgs, headerArgsWidth) : "";
-    const header = clippedHeaderArgs ? `${headerPrefix} ${clippedHeaderArgs}` : headerPrefix;
-    const headerArgsStart = headerPrefix.length + 1;
-    const clippedHeaderArgSegments = clippedHeaderArgs
-        ? clipAndShiftSegments(entry.headerArgSegments, headerArgsStart, clippedHeaderArgs.length)
-        : [];
-    const headerArgBaseSegments = clippedHeaderArgs
-        ? uncoveredSegments(headerArgsStart, header.length, toolOutputColor, clippedHeaderArgSegments)
-        : [];
     const target = { kind: "tool", id: entry.id };
     const showGutter = options.showGutter ?? true;
-    const headerLine = {
-        text: header,
+    const headerLines = renderToolHeaderLines({
+        entry,
+        expanded,
+        headerPrefix,
+        headerArgs,
+        headerArgsWidth,
+        stateIcon,
+        width,
         target,
-        colorOverride: toolColor,
-        ...(options.backgroundOverride && !options.skipHeaderBackground ? { backgroundOverride: options.backgroundOverride } : {}),
-        segments: [
-            { start: 0, end: stateIcon.length, foreground: toolStatusIconColor(entry, colors), bold: true },
-            { start: stateIcon.length, end: headerPrefix.length, bold: true },
-            ...headerArgBaseSegments,
-            ...clippedHeaderArgSegments,
-        ],
-    };
-    const headerLines = [headerLine];
+        toolColor,
+        toolOutputColor,
+        statusIconColor: toolStatusIconColor(entry, colors),
+        backgroundOverride: options.backgroundOverride && !options.skipHeaderBackground ? options.backgroundOverride : undefined,
+    });
+    const headerLine = headerLines[0];
+    if (!headerLine)
+        return [];
     if (expanded) {
-        headerLines.push(...renderToolBodyLines(entry.expandedText, width, target, toolOutputColor, entry.bodyStyle, colors, entry.syntaxHighlight, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter));
-        if (options.skipHeaderBackground && headerLines.length > 1) {
-            applyBackground(headerLines.slice(1));
+        const bodyLines = renderToolBodyLines(entry.expandedText, width, target, toolOutputColor, entry.bodyStyle, colors, entry.syntaxHighlight, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter);
+        if (options.skipHeaderBackground) {
+            applyBackground(bodyLines);
         }
         else {
-            applyBackground(headerLines);
+            applyBackground([...headerLines, ...bodyLines]);
         }
-        return headerLines;
+        return [...headerLines, ...bodyLines];
     }
     if (rule.compactHidden || (rule.defaultExpanded === true && !options.superCompact))
         return headerLines;
@@ -75,7 +70,7 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     if (!preview.text)
         return headerLines;
     const separator = " — ";
-    const availablePreviewWidth = width - stringDisplayWidth(header) - stringDisplayWidth(separator);
+    const availablePreviewWidth = width - stringDisplayWidth(headerLine.text) - stringDisplayWidth(separator);
     if (availablePreviewWidth <= 0)
         return headerLines;
     const markerPrefix = truncatedPreviewMarker();
@@ -83,8 +78,8 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const clippedPreview = sliceByDisplayWidth(previewText, availablePreviewWidth);
     if (!clippedPreview)
         return headerLines;
-    headerLine.text = `${header}${separator}${clippedPreview}`;
-    const previewStart = header.length + separator.length;
+    headerLine.text = `${headerLine.text}${separator}${clippedPreview}`;
+    const previewStart = headerLine.text.length - clippedPreview.length;
     const previewTextStart = previewStart + (preview.overflow ? markerPrefix.length : 0);
     headerLine.segments = [
         ...(headerLine.segments ?? []),
@@ -93,15 +88,54 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     ];
     return headerLines;
 }
-function clipAndShiftSegments(segments, offset, length) {
-    if (!segments || length <= 0)
+function renderToolHeaderLines(input) {
+    const visibleArgs = input.expanded
+        ? indexedWrappedText(input.headerArgs, Math.max(1, input.headerArgsWidth))
+        : indexedClippedText(input.headerArgs, input.headerArgsWidth);
+    const chunks = visibleArgs.length > 0 ? visibleArgs : [{ text: "", start: 0, end: 0 }];
+    const continuationIndent = " ".repeat(Math.min(stringDisplayWidth(input.headerPrefix) + 1, Math.max(0, input.width - 1)));
+    return chunks.map((chunk, index) => {
+        let linePrefix = continuationIndent;
+        if (index === 0)
+            linePrefix = chunk.text ? `${input.headerPrefix} ` : input.headerPrefix;
+        const text = `${linePrefix}${chunk.text}`;
+        const argStart = linePrefix.length;
+        const customSegments = input.entry.headerArgSegments
+            ?.flatMap((segment) => shiftSegmentToRange(segment, chunk.start, chunk.end))
+            .map((segment) => ({ ...segment, start: segment.start + argStart, end: segment.end + argStart })) ?? [];
+        const baseSegments = uncoveredSegments(argStart, text.length, input.toolOutputColor, customSegments);
+        return {
+            text,
+            target: input.target,
+            colorOverride: input.toolColor,
+            ...(input.backgroundOverride ? { backgroundOverride: input.backgroundOverride } : {}),
+            segments: [
+                ...(index === 0 ? [
+                    { start: 0, end: input.stateIcon.length, foreground: input.statusIconColor, bold: true },
+                    { start: input.stateIcon.length, end: input.headerPrefix.length, bold: true },
+                ] : []),
+                ...baseSegments,
+                ...customSegments,
+            ],
+        };
+    });
+}
+function indexedClippedText(text, width) {
+    if (width <= 0)
+        return [];
+    const clipped = sliceByDisplayWidth(text, width);
+    return clipped ? [{ text: clipped, start: 0, end: clipped.length }] : [];
+}
+function indexedWrappedText(text, width) {
+    if (!text)
         return [];
-    return segments.flatMap((segment) => {
-        const start = Math.max(0, segment.start);
-        const end = Math.min(length, segment.end);
-        if (end <= start)
-            return [];
-        return [{ ...segment, start: offset + start, end: offset + end }];
+    let cursor = 0;
+    return wrapDisplayLineByWords(text, width).map((chunk) => {
+        const foundAt = text.indexOf(chunk, cursor);
+        const start = foundAt >= 0 ? foundAt : cursor;
+        const end = start + chunk.length;
+        cursor = end;
+        return { text: chunk, start, end };
     });
 }
 function uncoveredSegments(start, end, foreground, coveredSegments) {

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/dist/bundled-extensions/session-title/index.js

@@ -81,6 +81,7 @@ export default function sessionTitle(pi) {
     const refreshTimers = new Set();
     let pendingGeneration;
     let forkTitleState;
+    let resourceCommandTitleSessionId;
     function abortCurrentRequest() {
         controller?.abort();
         controller = undefined;
@@ -349,6 +350,7 @@ export default function sessionTitle(pi) {
         sessionId = ctx.sessionManager.getSessionId();
         pendingGeneration = undefined;
         forkTitleState = undefined;
+        resourceCommandTitleSessionId = undefined;
         lastRenderedName = undefined;
         lastRenderedTitle = undefined;
         refreshSessionUi(ctx, { force: true });
@@ -360,6 +362,7 @@ export default function sessionTitle(pi) {
         clearRetryTimer();
         clearRefreshTimers();
         forkTitleState = undefined;
+        resourceCommandTitleSessionId = undefined;
     });
     function refreshOnEvent(ctx) {
         refreshSessionUi(ctx);
@@ -378,24 +381,33 @@ export default function sessionTitle(pi) {
         scheduleSessionUiRefresh(ctx);
         if (event.source === "extension")
             return { action: "continue" };
-        const fallbackInput = fallbackTitleInputFromPrompt(event.text, event.images);
-        if (!fallbackInput)
-            return { action: "continue" };
-        const titleInput = titleGenerationInputFromPrompt(event.text, event.images) ?? fallbackInput;
-        if (event.text.trimStart().startsWith("/"))
-            return { action: "continue" };
         const currentSessionId = ctx.sessionManager.getSessionId();
         sessionId = currentSessionId;
         const currentName = currentSessionName(ctx);
         const activeForkTitleState = forkTitleState?.sessionId === currentSessionId ? forkTitleState : undefined;
-        if (!activeForkTitleState && hasExistingUserMessage(ctx)) {
+        if (event.text.trimStart().startsWith("/")) {
+            if (!activeForkTitleState
+                && !currentName
+                && (resourceCommandTitleSessionId === currentSessionId || !hasExistingUserMessage(ctx))) {
+                resourceCommandTitleSessionId = currentSessionId;
+            }
+            return { action: "continue" };
+        }
+        const fallbackInput = fallbackTitleInputFromPrompt(event.text, event.images);
+        if (!fallbackInput)
+            return { action: "continue" };
+        const titleInput = titleGenerationInputFromPrompt(event.text, event.images) ?? fallbackInput;
+        const titleEligibleAfterResourceCommand = resourceCommandTitleSessionId === currentSessionId;
+        if (!activeForkTitleState && !titleEligibleAfterResourceCommand && hasExistingUserMessage(ctx)) {
             forkTitleState = undefined;
             return { action: "continue" };
         }
         if (currentName && (!activeForkTitleState || currentName !== activeForkTitleState.inheritedSessionName)) {
             forkTitleState = undefined;
+            resourceCommandTitleSessionId = undefined;
             return { action: "continue" };
         }
+        resourceCommandTitleSessionId = undefined;
         if (!currentConfig.enabled) {
             applyFallbackSessionTitle(ctx, currentConfig, activeForkTitleState
                 ? buildForkTitleInput(activeForkTitleState.parentTitle, fallbackInput)

package/external/pi-tools-suite/package.json

@@ -43,9 +43,9 @@
     "vscode-languageserver-protocol": "^3.17.5"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "0.82.1",
-    "@earendil-works/pi-coding-agent": "0.82.1",
-    "@earendil-works/pi-tui": "0.82.1",
+    "@earendil-works/pi-ai": "0.83.0",
+    "@earendil-works/pi-coding-agent": "0.83.0",
+    "@earendil-works/pi-tui": "0.83.0",
     "typebox": "*"
   },
   "devDependencies": {

package/external/pi-tools-suite/src/antigravity-auth/stream.ts

@@ -132,7 +132,7 @@ export function streamAntigravity(model: AntigravityModel, context: Context, opt
 			provider: model.provider,
 			model: model.id,
 			usage: baseUsage(),
-			stopReason: "stop",
+			stopReason: "pending",
 			timestamp: Date.now(),
 		};
 
@@ -258,12 +258,16 @@ export function streamAntigravity(model: AntigravityModel, context: Context, opt
 						stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
 					}
 				}
-				if (candidate?.finishReason) output.stopReason = mapStopReason(candidate.finishReason);
-				if (output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
+				if (candidate?.finishReason) {
+					output.rawStopReason = candidate.finishReason;
+					output.stopReason = mapStopReason(candidate.finishReason);
+					if (output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
+				}
 			}
 			closeOpenText();
 			closeOpenThinking();
 			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "pending") throw new Error("Antigravity stream ended without a finish reason");
 			if (output.stopReason === "error" || output.stopReason === "aborted") throw new Error("Antigravity stopped with an error finish reason");
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.78",
+  "version": "1.0.2",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {
@@ -75,9 +75,9 @@
     "prepublishOnly": "npm run check && npm run build:pix && npm run generate-schemas"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "0.82.1",
-    "@earendil-works/pi-coding-agent": "0.82.1",
-    "@earendil-works/pi-tui": "0.82.1",
+    "@earendil-works/pi-ai": "0.83.0",
+    "@earendil-works/pi-coding-agent": "0.83.0",
+    "@earendil-works/pi-tui": "0.83.0",
     "@mariozechner/clipboard": "^0.3.9",
     "jsonc-parser": "3.3.1",
     "typebox": "1.1.38",