@pimote/pimote 0.5.1 → 0.7.0

package/server/dist/ws-handler.js

@@ -3,12 +3,13 @@ import { execFile } from 'node:child_process';
 import { join, sep } from 'node:path';
 import { promisify } from 'node:util';
 import { resolveAllSlotPendingUi, resolveSlotPendingUi, replaySlotPendingUiRequests } from './session-manager.js';
+import { LoginBusyError } from './login-orchestrator.js';
 import { getMergedPanelCards } from './panel-state.js';
 import { createExtensionUIBridge } from './extension-ui-bridge.js';
 import { findExternalPiProcesses, killExternalPiProcesses } from './takeover.js';
 import { mapAgentMessages, extractMessageEntryIds, applyEntryIds } from './message-mapper.js';
-import { getGitBranch } from './git-branch.js';
 import { sumAssistantCostUsd } from './session-cost.js';
+import { completeFileRefs } from './file-references.js';
 import { CallBindError } from './voice-orchestrator.js';
 /** Parse data-URL encoded images into the shape the pi SDK expects. */
 function parseDataUrlImages(images) {
@@ -84,17 +85,21 @@ export function mapTreeNodes(nodes) {
 /**
  * Create command context actions for extension commands.
  * Captures the ManagedSlot (stable lifetime), not a transient handler.
- * Session resets are routed through slot.connection.onSessionReset which the
- * current handler sets on claim and clears on cleanup.
+ * Session resets funnel through sessionManager.applySessionReset, which always
+ * reconciles the session map and then notifies the slot's current owner (if any)
+ * via slot.connection.onSessionReset — so a reset with no live owner still re-keys.
  */
-function createCommandContextActions(slot) {
+function createCommandContextActions(slot, sessionManager) {
     return {
         waitForIdle: () => {
             if (!slot.session.isStreaming)
                 return Promise.resolve();
             return new Promise((resolve) => {
                 const unsubscribe = slot.session.subscribe((event) => {
-                    if (event.type === 'agent_end') {
+                    // A `willRetry` agent_end is not a real end — the SDK will re-run the
+                    // prompt after backoff. Resolving here would hand control back mid-run.
+                    // Wait for the terminal (willRetry=false) agent_end instead.
+                    if (event.type === 'agent_end' && !event.willRetry) {
                         unsubscribe();
                         resolve();
                     }
@@ -104,25 +109,25 @@ function createCommandContextActions(slot) {
         newSession: async (options) => {
             const result = await slot.runtime.newSession(options);
             if (!result.cancelled)
-                await slot.connection?.onSessionReset?.(slot);
+                await sessionManager.applySessionReset(slot);
             return { cancelled: result.cancelled };
         },
         fork: async (entryId) => {
             const result = await slot.runtime.fork(entryId);
             if (!result.cancelled)
-                await slot.connection?.onSessionReset?.(slot);
+                await sessionManager.applySessionReset(slot);
             return { cancelled: result.cancelled };
         },
         navigateTree: async (targetId, options) => {
             const result = await slot.session.navigateTree(targetId, options);
             if (!result.cancelled)
-                await slot.connection?.onSessionReset?.(slot);
+                await sessionManager.applySessionReset(slot);
             return { cancelled: result.cancelled };
         },
         switchSession: async (sessionPath) => {
             const result = await slot.runtime.switchSession(sessionPath);
             if (!result.cancelled)
-                await slot.connection?.onSessionReset?.(slot);
+                await sessionManager.applySessionReset(slot);
             return { cancelled: result.cancelled };
         },
         reload: () => slot.session.reload(),
@@ -137,7 +142,12 @@ export class WsHandler {
     clientRegistry;
     voiceOrchestrator;
     subscribedSessions = new Set();
+    fdWarningEmitted = false;
     viewedSessionId = null;
+    /** Pending login prompt/select inputs keyed by requestId (mirrors pendingUiResponses). */
+    pendingLoginInputs = new Map();
+    /** AbortController for the in-flight login flow this connection initiated, if any. */
+    loginAbort = null;
     clientId;
     constructor(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry, voiceOrchestrator) {
         this.sessionManager = sessionManager;
@@ -161,6 +171,12 @@ export class WsHandler {
             this.sendResponse('unknown', false, undefined, 'Invalid JSON');
             return;
         }
+        // Guard against non-object payloads (e.g. `null`, a bare number/string):
+        // dereferencing `command.id` on those throws outside the response try block.
+        if (command === null || typeof command !== 'object') {
+            this.sendResponse('unknown', false, undefined, 'Invalid command');
+            return;
+        }
         const id = command.id ?? 'unknown';
         try {
             switch (command.type) {
@@ -498,7 +514,7 @@ export class WsHandler {
                     const connection = {
                         ws: this.ws,
                         connectedClientId: this.clientId,
-                        onSessionReset: (s) => this.handleSessionReset(s),
+                        onSessionReset: (s, outcome) => this.handleSessionReset(s, outcome),
                     };
                     try {
                         const data = await this.voiceOrchestrator.bindCall({
@@ -521,9 +537,15 @@ export class WsHandler {
                     break;
                 }
                 case 'call_end': {
+                    // Route call_ended to the call's OWNER, not necessarily the requester:
+                    // a non-owner ending the call must still tear down the owner's
+                    // VoiceCallStore (otherwise it stays `active` until WebRTC dies). In the
+                    // normal flow requester === owner, so this targets the same socket.
+                    const ownerClientId = this.sessionManager.getSlot(command.sessionId)?.connection?.connectedClientId;
                     await this.voiceOrchestrator?.endCall({ sessionId: command.sessionId, reason: 'user_hangup' });
                     this.sendResponse(id, true);
-                    this.sendEvent({ type: 'call_ended', sessionId: command.sessionId, reason: 'user_hangup' });
+                    const ownerHandler = ownerClientId ? this.clientRegistry.get(ownerClientId) : undefined;
+                    (ownerHandler ?? this).sendCallEndedEvent(command.sessionId, 'user_hangup');
                     break;
                 }
                 // ---- Client diagnostic logs (voice/call tracing) ----
@@ -653,6 +675,7 @@ export class WsHandler {
                 case 'get_session_meta':
                 case 'get_commands':
                 case 'complete_args':
+                case 'complete_file_refs':
                 case 'set_session_name':
                 case 'dequeue_steering':
                 case 'fork':
@@ -661,6 +684,57 @@ export class WsHandler {
                     await this.handleSessionCommand(command, id);
                     break;
                 }
+                // -- Global login commands (NOT session-scoped) --
+                case 'login_list': {
+                    const providers = this.sessionManager.getLoginOrchestrator().listProviders();
+                    this.sendResponse(id, true, { providers });
+                    break;
+                }
+                case 'login_begin': {
+                    const orchestrator = this.sessionManager.getLoginOrchestrator();
+                    if (orchestrator.isBusy()) {
+                        this.sendResponse(id, true, { ok: false, reason: 'busy' });
+                        break;
+                    }
+                    const transport = this.createLoginTransport();
+                    const flowController = this.loginAbort;
+                    // Drive the flow async — it emits login_step events as it goes and a
+                    // terminal `done` step on completion. Respond `ok` immediately.
+                    orchestrator
+                        .runLogin(command.providerId, transport)
+                        .catch((err) => {
+                        if (err instanceof LoginBusyError)
+                            return;
+                        console.error('[WsHandler] login flow error:', err);
+                    })
+                        .finally(() => {
+                        // Settle any inputs still outstanding when the flow ends for a
+                        // reason other than a client cancel (provider-side timeout,
+                        // network error during the manual-input race) so the promises pi
+                        // awaited don't dangle, and clear the now-completed controller.
+                        this.settlePendingLoginInputs();
+                        if (this.loginAbort === flowController) {
+                            this.loginAbort = null;
+                        }
+                    });
+                    this.sendResponse(id, true, { ok: true });
+                    break;
+                }
+                case 'login_input': {
+                    const pending = this.pendingLoginInputs.get(command.requestId);
+                    if (pending) {
+                        this.pendingLoginInputs.delete(command.requestId);
+                        pending.resolve(command.value);
+                    }
+                    this.sendResponse(id, true);
+                    break;
+                }
+                case 'login_cancel': {
+                    this.loginAbort?.abort();
+                    this.settlePendingLoginInputs('login cancelled');
+                    this.sendResponse(id, true);
+                    break;
+                }
                 default: {
                     this.sendResponse(id, false, undefined, `Unknown command type: ${command.type}`);
                 }
@@ -691,7 +765,7 @@ export class WsHandler {
                 if (trimmed === '/new') {
                     const result = await slot.runtime.newSession();
                     if (!result.cancelled)
-                        await slot.connection?.onSessionReset?.(slot);
+                        await this.sessionManager.applySessionReset(slot);
                     this.sendResponse(id, true, { success: !result.cancelled });
                     break;
                 }
@@ -734,7 +808,15 @@ export class WsHandler {
             case 'abort': {
                 // Resolve pending UI responses first so stuck dialogs unblock
                 resolveAllSlotPendingUi(slot);
-                const abortResult = await Promise.race([session.abort().then(() => 'ok'), new Promise((resolve) => setTimeout(() => resolve('timeout'), 30_000))]);
+                let abortWatchdog;
+                const abortResult = await Promise.race([
+                    session.abort().then(() => 'ok'),
+                    new Promise((resolve) => {
+                        abortWatchdog = setTimeout(() => resolve('timeout'), 30_000);
+                    }),
+                ]);
+                if (abortWatchdog !== undefined)
+                    clearTimeout(abortWatchdog);
                 if (abortResult === 'timeout') {
                     console.error(`[WsHandler] session.abort() did not resolve within 30s (sessionId=${sessionId})`);
                 }
@@ -823,7 +905,7 @@ export class WsHandler {
             case 'new_session': {
                 const result = await slot.runtime.newSession();
                 if (!result.cancelled)
-                    await slot.connection?.onSessionReset?.(slot);
+                    await this.sessionManager.applySessionReset(slot);
                 this.sendResponse(id, true, { success: !result.cancelled });
                 break;
             }
@@ -835,9 +917,14 @@ export class WsHandler {
             case 'get_session_meta': {
                 const contextUsage = session.getContextUsage();
                 const meta = {
-                    gitBranch: getGitBranch(slot.folderPath),
+                    gitBranch: this.sessionManager.getLastKnownGitBranch(sessionId),
                     contextUsage: contextUsage ? { percent: contextUsage.percent, contextWindow: contextUsage.contextWindow } : null,
-                    lifetimeCostUsd: sumAssistantCostUsd(session.sessionManager.getBranch()),
+                    // getEntries() (not getBranch()) so cost spans ALL branches in the
+                    // session file, not just the current leaf's branch. Survives live
+                    // switches and reload-from-disk because it is recomputed from the
+                    // session manager's rehydrated entries every call. See session-cost.ts
+                    // for what this figure excludes.
+                    lifetimeCostUsd: sumAssistantCostUsd(session.sessionManager.getEntries()),
                 };
                 this.sendResponse(id, true, { meta });
                 break;
@@ -871,7 +958,7 @@ export class WsHandler {
                     });
                 }
                 // Pimote built-in commands
-                commands.push({ name: 'new', description: 'Start a new session', hasArgCompletions: false }, { name: 'reload', description: 'Reload extensions and skills', hasArgCompletions: false }, { name: 'tree', description: 'Navigate session history tree', hasArgCompletions: false });
+                commands.push({ name: 'new', description: 'Start a new session', hasArgCompletions: false }, { name: 'reload', description: 'Reload extensions and skills', hasArgCompletions: false }, { name: 'tree', description: 'Navigate session history tree', hasArgCompletions: false }, { name: 'login', description: 'Log in to a model provider', hasArgCompletions: false });
                 this.sendResponse(id, true, { commands });
                 break;
             }
@@ -890,6 +977,14 @@ export class WsHandler {
                 this.sendResponse(id, true, { items: items ?? null });
                 break;
             }
+            case 'complete_file_refs': {
+                const result = await completeFileRefs({ prefix: command.prefix, cwd: slot.folderPath });
+                if (!result.fdAvailable) {
+                    this.emitFdMissingWarning(sessionId);
+                }
+                this.sendResponse(id, true, { items: result.items });
+                break;
+            }
             case 'set_session_name': {
                 session.setSessionName(command.name);
                 this.sendResponse(id, true);
@@ -902,7 +997,7 @@ export class WsHandler {
                 }
                 const forkResult = await slot.runtime.fork(command.entryId);
                 if (!forkResult.cancelled) {
-                    await this.handleSessionReset(slot);
+                    await this.sessionManager.applySessionReset(slot);
                 }
                 const forkData = { cancelled: forkResult.cancelled };
                 if (forkResult.selectedText !== undefined) {
@@ -942,7 +1037,7 @@ export class WsHandler {
                     });
                 }
                 if (!result.cancelled) {
-                    await this.handleSessionReset(slot);
+                    await this.sessionManager.applySessionReset(slot);
                 }
                 const data = { cancelled: result.cancelled };
                 if (result.editorText !== undefined) {
@@ -983,12 +1078,14 @@ export class WsHandler {
         }
     }
     /** Bind a slot to this client — sets ownership, WebSocket routing,
-     *  and subscribes to events. Extensions are bound once on first claim. */
+     *  and subscribes to events. Extensions are bound once on first claim. Public
+     *  so the voice force-bind path (displaceOwner wiring) can transfer ownership
+     *  through this same single operation, exactly like open_session does. */
     async claimSession(sessionId, slot) {
         const connection = {
             ws: this.ws,
             connectedClientId: this.clientId,
-            onSessionReset: (s) => this.handleSessionReset(s),
+            onSessionReset: (s, outcome) => this.handleSessionReset(s, outcome),
         };
         slot.connection = connection;
         // Note: do NOT touch `idleSince` here. Idleness is an agent-level concept driven by
@@ -1001,50 +1098,42 @@ export class WsHandler {
             const uiContext = createExtensionUIBridge(slot, this.pushNotificationService, {
                 isVoiceModeActive: () => this.voiceOrchestrator?.isCallActive(sessionId) ?? false,
             });
-            const commandContextActions = createCommandContextActions(slot);
+            const commandContextActions = createCommandContextActions(slot, this.sessionManager);
             await slot.session.bindExtensions({ uiContext, commandContextActions });
             slot.sessionState.extensionsBound = true;
         }
         // Re-deliver any pending UI requests to the new client (recovers lost dialogs)
         replaySlotPendingUiRequests(slot);
     }
-    /** Handle a session reset (newSession, fork, switchSession).
-     *  Called via slot.connection.onSessionReset after the runtime has replaced the session. */
-    async handleSessionReset(slot) {
-        const newSessionId = slot.runtime.session.sessionId;
-        const oldSessionId = slot.sessionState.id;
-        // navigateTree stays in the same file — same session ID, just resync
-        if (newSessionId === oldSessionId) {
-            this.sendFullResyncForSession(oldSessionId, slot);
+    /** Notify-only reaction to a session reset that the session manager has ALREADY
+     *  reconciled in the map (rebuild + collision-evict + re-key). Installed as the
+     *  owning connection's onSessionReset; runs only for the slot's current owner.
+     *  Does no map mutation itself — see SessionManager.applySessionReset. */
+    async handleSessionReset(slot, outcome) {
+        // navigateTree stays in the same file — same session ID, just resync.
+        if (outcome.kind === 'unchanged') {
+            this.sendFullResyncForSession(slot.sessionState.id, slot);
             return;
         }
-        // Session ID changed — rebuild session state in-place on the same slot.
-        // rebuildSessionState refreshes slot.folderPath from the new session's header cwd,
-        // so capture folderPath AFTER the rebuild to pick up the new value (fork-from can
-        // change cwd, e.g. the worktree extension).
-        // Rebuild session state (tears down old, creates new from runtime.session)
-        this.sessionManager.rebuildSessionState(slot);
-        const folderPath = slot.folderPath;
-        // Re-key the session map
-        this.sessionManager.reKeySession(slot, oldSessionId, newSessionId);
+        const { oldId, newId, folderPath } = outcome;
         // Update handler bookkeeping
-        this.subscribedSessions.delete(oldSessionId);
-        this.subscribedSessions.add(newSessionId);
-        if (this.viewedSessionId === oldSessionId) {
-            this.viewedSessionId = newSessionId;
+        this.subscribedSessions.delete(oldId);
+        this.subscribedSessions.add(newId);
+        if (this.viewedSessionId === oldId) {
+            this.viewedSessionId = newId;
         }
         // Rebind extension UI bridge (new session state for dialog routing)
         const uiContext = createExtensionUIBridge(slot, this.pushNotificationService, {
-            isVoiceModeActive: () => this.voiceOrchestrator?.isCallActive(newSessionId) ?? false,
+            isVoiceModeActive: () => this.voiceOrchestrator?.isCallActive(newId) ?? false,
         });
-        const commandContextActions = createCommandContextActions(slot);
+        const commandContextActions = createCommandContextActions(slot, this.sessionManager);
         await slot.session.bindExtensions({ uiContext, commandContextActions });
         slot.sessionState.extensionsBound = true;
         // Notify owning client: session replaced (client re-keys in place)
         this.sendEvent({
             type: 'session_replaced',
-            oldSessionId,
-            newSessionId,
+            oldSessionId: oldId,
+            newSessionId: newId,
             folder: {
                 path: folderPath,
                 name: folderPath.split('/').pop() ?? folderPath,
@@ -1054,8 +1143,22 @@ export class WsHandler {
             },
         });
         // Broadcast sidebar updates for both old (now inactive) and new (now active)
-        WsHandler.broadcastSidebarUpdate(oldSessionId, folderPath, this.sessionManager, this.clientRegistry);
-        WsHandler.broadcastSidebarUpdate(newSessionId, folderPath, this.sessionManager, this.clientRegistry);
+        WsHandler.broadcastSidebarUpdate(oldId, folderPath, this.sessionManager, this.clientRegistry);
+        WsHandler.broadcastSidebarUpdate(newId, folderPath, this.sessionManager, this.clientRegistry);
+    }
+    /** Surface the fd-missing warning at most once per connection (fire-and-forget toast). */
+    emitFdMissingWarning(sessionId) {
+        if (this.fdWarningEmitted)
+            return;
+        this.fdWarningEmitted = true;
+        this.sendEvent({
+            type: 'extension_ui_request',
+            sessionId,
+            requestId: `fd-missing-${Date.now()}`,
+            method: 'notify',
+            message: 'fd not found — file autocomplete is unavailable. Install fd to enable it.',
+            notifyType: 'warning',
+        });
     }
     buildFolderInfo(folderPath) {
         return {
@@ -1153,7 +1256,9 @@ export class WsHandler {
         // orchestrator bookkeeping and surface `call_ended { reason: 'displaced' }`
         // so their VoiceCallStore tears down alongside the session_closed.
         if (this.voiceOrchestrator?.isCallActive(sessionId)) {
-            void this.voiceOrchestrator.endCall({ sessionId, reason: 'displaced' });
+            this.voiceOrchestrator.endCall({ sessionId, reason: 'displaced' }).catch((err) => {
+                console.warn('[voice] endCall on displace failed', err);
+            });
             this.sendEvent({
                 type: 'call_ended',
                 sessionId,
@@ -1214,8 +1319,39 @@ export class WsHandler {
             console.error('[WsHandler] Failed to send event:', err);
         }
     }
+    /** Reject + clear any outstanding login prompt/select inputs for this
+     *  connection. pi attaches a `.catch` to the manual-code promise, so rejecting
+     *  is safe and won't surface an unhandled rejection. */
+    settlePendingLoginInputs(reason = 'login flow ended') {
+        for (const [, pending] of this.pendingLoginInputs) {
+            pending.reject(new Error(reason));
+        }
+        this.pendingLoginInputs.clear();
+    }
+    /** Build a connection-bound LoginTransport: events flow to this client, and
+     *  prompt/select inputs resolve via this connection's pendingLoginInputs map. */
+    createLoginTransport() {
+        const controller = new AbortController();
+        this.loginAbort = controller;
+        const awaitInput = (requestId) => new Promise((resolve, reject) => {
+            this.pendingLoginInputs.set(requestId, { resolve, reject });
+        });
+        return {
+            emit: (step) => {
+                this.sendEvent({ type: 'login_step', step });
+            },
+            requestInput: ({ requestId, message, placeholder, allowEmpty }) => {
+                this.sendEvent({ type: 'login_step', step: { kind: 'prompt', requestId, message, placeholder, allowEmpty } });
+                return awaitInput(requestId);
+            },
+            requestSelect: ({ requestId, message, options }) => {
+                this.sendEvent({ type: 'login_step', step: { kind: 'select', requestId, message, options } });
+                return awaitInput(requestId);
+            },
+            signal: controller.signal,
+        };
+    }
     emitBufferedSessionEvent(slot, sessionId, sdkEvent) {
-        let forwarded = false;
         slot.sessionState.eventBuffer.onEvent(sdkEvent, sessionId, (event) => {
             // Augment agent_end with message entry IDs so the client can enable
             // fork targets on messages that arrived via streaming (without IDs).
@@ -1223,20 +1359,8 @@ export class WsHandler {
                 const entryIds = extractMessageEntryIds(slot.session.sessionManager.getBranch());
                 event.messageEntryIds = entryIds;
             }
-            forwarded = true;
             this.sendEvent(event);
         }, () => slot.session.messages[slot.session.messages.length - 1]);
-        // Test doubles for EventBuffer may no-op on onEvent().
-        // Fallback keeps lifecycle visibility in tests while real runtime uses buffered forwarding above.
-        if (!forwarded) {
-            const cursorBase = slot.sessionState.eventBuffer.currentCursor;
-            const cursor = typeof cursorBase === 'number' ? cursorBase + 1 : 1;
-            this.sendEvent({
-                ...sdkEvent,
-                sessionId,
-                cursor,
-            });
-        }
     }
     /** Send a full_resync event to the client for the given managed session.
      *  Used when the underlying pi session is reset (newSession, switchSession, fork, navigateTree). */
@@ -1313,13 +1437,19 @@ export class WsHandler {
             sessionName,
             firstMessage,
             messageCount,
-            gitBranch: slot ? getGitBranch(slot.folderPath) : null,
+            gitBranch: slot ? sessionManager.getLastKnownGitBranch(sessionId) : null,
         };
         for (const [, handler] of clientRegistry) {
             handler.sendToClient(event);
         }
     }
     cleanup() {
+        // If this connection had a login flow in flight, abort it and settle any
+        // dangling input promises (mirror of `login_cancel`). The LoginOrchestrator
+        // is single-flight and server-wide, so leaving it busy would wedge logins
+        // for every client until restart.
+        this.loginAbort?.abort();
+        this.settlePendingLoginInputs('connection closed');
         for (const sid of this.subscribedSessions) {
             const slot = this.sessionManager.getSession(sid);
             if (slot) {

package/shared/dist/protocol.d.ts

@@ -212,6 +212,19 @@ export interface CompleteArgsCommand extends CommandBase {
     commandName: string;
     prefix: string;
 }
+/**
+ * `@`-file-path autocomplete request (client → server). Mirrors pi's interactive
+ * TUI `@` behavior: the client extracts the `@`-token immediately before the
+ * cursor (including `@"…"` quoted tokens) and asks the server for `fd`-backed
+ * path suggestions resolved against the session's working directory. The
+ * response reuses the generic `AutocompleteResponseItem` shape. This is
+ * autocomplete-only — there is no server-side `@`-reference expansion.
+ */
+export interface CompleteFileRefsCommand extends CommandBase {
+    type: 'complete_file_refs';
+    /** The client-extracted `@`-token as typed, including the leading `@` (and opening quote if quoted), e.g. `@src/`, `@"my dir/`. */
+    prefix: string;
+}
 export interface CommandInfo {
     name: string;
     description: string;
@@ -344,6 +357,39 @@ export interface CallEndCommand extends CommandBase {
 export type CallBindErrorCode = 'call_bind_failed_session_not_found' | 'call_bind_failed_owned' | 'call_bind_failed_internal';
 /** Reason code returned when an extension attempts a UI bridge call during a voice call. */
 export declare const UI_BRIDGE_DISABLED_IN_VOICE_MODE = "ui_bridge_disabled_in_voice_mode";
+/** A single OAuth provider's logged-in status, for the login picker. */
+export interface LoginProviderInfo {
+    id: string;
+    name: string;
+    loggedIn: boolean;
+}
+/** List OAuth providers and their logged-in status. resp: LoginListResponseData */
+export interface LoginListCommand extends CommandBase {
+    type: 'login_list';
+}
+/** Begin an interactive login flow for a provider. resp: LoginBeginResponseData */
+export interface LoginBeginCommand extends CommandBase {
+    type: 'login_begin';
+    providerId: string;
+}
+/** Resolve a pending login prompt/select keyed by `requestId`. */
+export interface LoginInputCommand extends CommandBase {
+    type: 'login_input';
+    requestId: string;
+    value: string;
+}
+/** Abort the in-flight login flow (fires the AbortSignal, rejects pending input). */
+export interface LoginCancelCommand extends CommandBase {
+    type: 'login_cancel';
+}
+export interface LoginListResponseData {
+    providers: LoginProviderInfo[];
+}
+export interface LoginBeginResponseData {
+    ok: boolean;
+    /** Present when ok === false because a login flow is already in progress. */
+    reason?: 'busy';
+}
 export interface ExtensionUiResponseCommand extends CommandBase {
     type: 'extension_ui_response';
     requestId: string;
@@ -351,7 +397,7 @@ export interface ExtensionUiResponseCommand extends CommandBase {
     confirmed?: boolean;
     cancelled?: boolean;
 }
-export type PimoteCommand = PromptCommand | SteerCommand | FollowUpCommand | AbortCommand | ClientLogCommand | SetModelCommand | CycleModelCommand | GetAvailableModelsCommand | SetThinkingLevelCommand | CycleThinkingLevelCommand | CompactCommand | SetAutoCompactionCommand | GetStateCommand | GetMessagesCommand | NewSessionCommand | GetSessionStatsCommand | GetSessionMetaCommand | GetCommandsCommand | CompleteArgsCommand | SetSessionNameCommand | DequeueSteeringCommand | ForkCommand | NavigateTreeCommand | SetTreeLabelCommand | CreateProjectCommand | RenameSessionCommand | ListFoldersCommand | ListSessionsCommand | OpenSessionCommand | CloseSessionCommand | DeleteSessionCommand | ArchiveSessionCommand | TakeoverFolderCommand | ViewSessionCommand | RegisterPushCommand | UnregisterPushCommand | KillConflictingProcessesCommand | KillConflictingSessionsCommand | ExtensionUiResponseCommand | CallBindCommand | CallEndCommand;
+export type PimoteCommand = PromptCommand | SteerCommand | FollowUpCommand | AbortCommand | ClientLogCommand | SetModelCommand | CycleModelCommand | GetAvailableModelsCommand | SetThinkingLevelCommand | CycleThinkingLevelCommand | CompactCommand | SetAutoCompactionCommand | GetStateCommand | GetMessagesCommand | NewSessionCommand | GetSessionStatsCommand | GetSessionMetaCommand | GetCommandsCommand | CompleteArgsCommand | CompleteFileRefsCommand | SetSessionNameCommand | DequeueSteeringCommand | ForkCommand | NavigateTreeCommand | SetTreeLabelCommand | CreateProjectCommand | RenameSessionCommand | ListFoldersCommand | ListSessionsCommand | OpenSessionCommand | CloseSessionCommand | DeleteSessionCommand | ArchiveSessionCommand | TakeoverFolderCommand | ViewSessionCommand | RegisterPushCommand | UnregisterPushCommand | KillConflictingProcessesCommand | KillConflictingSessionsCommand | ExtensionUiResponseCommand | CallBindCommand | CallEndCommand | LoginListCommand | LoginBeginCommand | LoginInputCommand | LoginCancelCommand;
 interface SessionEventBase {
     /** Which session produced this event */
     sessionId: string;
@@ -366,6 +412,12 @@ export interface AgentStartEvent extends SessionEventBase {
 export interface AgentEndEvent extends SessionEventBase {
     type: 'agent_end';
     error?: string;
+    /** True when this `agent_end` is followed by an automated retry (the SDK
+     *  detected a retryable error and will re-run the prompt). When set, this
+     *  is NOT a real end — a fresh `agent_start` will follow after backoff, so
+     *  consumers must not treat it as the run finishing (no idle transition,
+     *  no "needs attention", no completion notification). */
+    willRetry?: boolean;
     /** Entry IDs for all messages, zipped 1:1 with the session message list.
      *  Sent so the client can enable fork targets on messages received via
      *  streaming events (which don't carry entry IDs individually). */
@@ -622,11 +674,54 @@ export interface VoiceInterruptEntryData {
     heard_text: string;
     kind: 'abort' | 'rollback';
 }
+/**
+ * A single step in an interactive login flow, server → client. Rendered
+ * generically by the login modal. `prompt`/`select` steps carry a `requestId`
+ * the client echoes back via `login_input` to resolve the pending input. The
+ * `done` step is terminal. Login is global (not session-scoped), so this event
+ * carries no `sessionId`.
+ */
+export type LoginStep = {
+    kind: 'auth';
+    url: string;
+    instructions?: string;
+} | {
+    kind: 'device_code';
+    userCode: string;
+    verificationUri: string;
+    expiresInSeconds?: number;
+} | {
+    kind: 'prompt';
+    requestId: string;
+    message: string;
+    placeholder?: string;
+    allowEmpty?: boolean;
+} | {
+    kind: 'select';
+    requestId: string;
+    message: string;
+    options: {
+        id: string;
+        label: string;
+    }[];
+} | {
+    kind: 'progress';
+    message: string;
+} | {
+    kind: 'done';
+    success: boolean;
+    providerName: string;
+    error?: string;
+};
+export interface LoginStepEvent {
+    type: 'login_step';
+    step: LoginStep;
+}
 export interface VersionMismatchEvent {
     type: 'version_mismatch';
     serverVersion: string;
 }
-export type PimoteEvent = PimoteSessionEvent | ExtensionUiRequestEvent | SessionConflictEvent | SessionOpenedEvent | SessionClosedEvent | SessionDeletedEvent | SessionRenamedEvent | SessionArchivedEvent | SessionReplacedEvent | SessionStateChangedEvent | ConnectionRestoredEvent | SessionRestoreEvent | BufferedEventsEvent | FullResyncEvent | PanelUpdateEvent | NavigateEvent | CallBindResponse | CallReadyEvent | CallEndedEvent | CallStatusEvent | VersionMismatchEvent;
+export type PimoteEvent = PimoteSessionEvent | ExtensionUiRequestEvent | SessionConflictEvent | SessionOpenedEvent | SessionClosedEvent | SessionDeletedEvent | SessionRenamedEvent | SessionArchivedEvent | SessionReplacedEvent | SessionStateChangedEvent | ConnectionRestoredEvent | SessionRestoreEvent | BufferedEventsEvent | FullResyncEvent | PanelUpdateEvent | NavigateEvent | CallBindResponse | CallReadyEvent | CallEndedEvent | CallStatusEvent | LoginStepEvent | VersionMismatchEvent;
 export interface PimoteResponse<T = unknown> {
     /** Matches the `id` from the originating PimoteCommand */
     id: string;